黑马程序员技术交流社区

标题: 关于java中锁的问题 [打印本页]

作者: 张凯 时间: 2012-7-17 20:24
标题: 关于java中锁的问题
本帖最后由张凯于 2012-7-19 20:02 编辑

代码如下：

package com;

public class method {
private static method m = null;

private static byte[] b = new byte[0];
private method(){

}

public static method getInstance(){
if(m==null){
m = new method();
}
return m;
}

public void print1(){
synchronized (b) {
for(int i = 0;i<1220;i++){
System.out.println(Thread.currentThread().getName()+i);
}
}

}

public void print2(){
synchronized (b) {
for(int i = 0;i<1220;i++){
System.out.println(Thread.currentThread().getName()+i);
}
}
}

}

package com;

public class test {

public static void main(String[] args) {
test t=new test();
t.init();
}

public void init(){
Runnable r = new thread1();
Thread t = new Thread(r,"A");
t.start();
Runnable r1 = new thread2();
Thread t1 = new Thread(r,"B");
t1.start();
}
public class thread1 implements Runnable{
public void run() {
method m = method.getInstance();
m.print1();

}

}

public class thread2 implements Runnable{
public void run() {
method m = method.getInstance();
m.print2();

}

}

}
问题：
如若synchronized (b)中的b是static 则执行的结果是AB按顺序出现，若b是非static则AB交替出现，若b换成thisAB也是交替出现。谁能给我解释下为什么吗，method类中的两个方法里的锁不是指向同一个对象吗。谢谢。。。。

作者: 任文杰 时间: 2012-7-17 20:48
由于，类method采用单例模式，故在整个程序运行过程中，只有一个method实例在运行，故用this可以实现同步互斥效果。尽管其采用单例模式，但其中的成员b，在测试类test中，被初始化两次，若b是类成员，虽然初始化两次，但是同一个对象，实现了同步互斥的效果。若b前不加static修饰，则会初始化两次，会产生两个不同的对象，达不到互斥的效果。

作者: 柯玲 时间: 2012-7-17 23:55
首先，在我的机器上运行并没有出现你所说的情况，三种写法都是AB按顺序打印
其次，这段代码违背了同步的一个前提：必须有两个或两个以上的线程；
这边看似创建了两个线程，实则是两个独立的线程操作各自的方法，互不干扰。就拿thread1来说，只给它创建了一个线程t去执行print1方法；那么加不加锁都是一样的效果。
最后，print1和print2虽然操作的是同一资源：method的实例对象，但是它们是被独立的线程执行的，就按照main方法创建线程的顺序依次输出

作者: 陈淑飞 时间: 2012-7-18 09:01
本帖最后由陈淑飞于 2012-7-18 09:06 编辑

柯玲发表于 2012-7-17 23:55
首先，在我的机器上运行并没有出现你所说的情况，三种写法都是AB按顺序打印
其次，这段代码违背了同步的一 ...

print1和print2虽然操作的是同一资源：method的实例对象

不太认可这句。其实，b中加不加static很关键。
当加static后 b就成了静态成员变量，所有实例共享，只有一份。此时，对于这两个线程来说，就是加了同一把锁，那么结果只能是谁先抢到锁，谁就先跑完，另一个再跑，所以A跑完后，B再跑。

当static 不修饰b 时，b 就是成员变量了，这里同步块的中b，是否是同一锁，那就要看method m是否是同一对象了。显然，这里他虽然用了“单例模式”，但是他用的，只适合单线程时，得到的是同一对象。而多线程中，可能就是两个method对象了。正确的懒汉式的单例我就不贴代码了。贴子上有很多这样的例子。

这里为了说明，用这种单例，可能会产生两个不同的method m对象，我贴下代码，大家可以验证下：

public class thread1 implements Runnable{
method m ;
thread2 t = new thread2 ();
public void run() {
m = method.getInstance();
m.print1();
t.compareMeth(m);
}
}
public class thread2 implements Runnable{
method m ;
public void run() {
m = method.getInstance();
m.print2();
}
public void compareMeth(method m){
if(this.m == m)
System.out.println("这两个对象是同一对象了，即是同一锁了");
else
System.out.println("这两个对象不是同一对象了，即是两把不同的锁了");
}
}

复制代码

从图中，可以证明。这种单例产生了两个不同的method 对象了，那么自然去掉static 修饰的b 或用 this 来做锁同步时，是两个不同的对象锁，
这两个线程当然又去竞争CPU资源，最终会交替的打印A、B了。

作者: 柯玲 时间: 2012-7-18 10:25

陈淑飞发表于 2012-7-18 09:01
不太认可这句。其实，b中加不加static很关键。
当加static后 b就成了静态成员变量，所有实例共享，只 ...

此处你的单例模式是懒汉模式加载，会出现一个线程进入getInstance()的if(m==null)里面，然后放弃CPU执行权，被另一个线程抢到也进入到getInstance()的if判断语句里，当线程醒的时候，就创建了两个method的实例对象

作者: 柯玲 时间: 2012-7-18 10:39
建议你把单例改为饿汉式加载，即：

private static method m = new method();
private method() {}
public static method getInstance() {
return m;
}

复制代码

就不会产生两个不同的method对象，现在证明你原本的代码也不满足同步的另一个前提：多个线程操作同一个资源。
1、将创建method实例的方法改为饿汉加载，就可以保证为同一个资源。
2、操作print1()、print2()的线程都改为两个或两个以上，不要只创建一个了

作者: 张凯 时间: 2012-7-19 20:02

陈淑飞发表于 2012-7-18 09:01
不太认可这句。其实，b中加不加static很关键。
当加static后 b就成了静态成员变量，所有实例共享，只 ...

谢谢，明白了。

作者: 陈欢 时间: 2012-7-19 22:13
在Java中，使用synchronized关键字来进行线程的同步

一个设置了synchronized关键字的方法自动成为同步方法
进入方法则相当于以当前对象为信号量，上锁。退出时解锁。

Java还提供了wait()和notify(),notifyAll()方法辅助进行同步
wait()会解锁当前的信号量，使线程进入堵塞状态。直到使用
同一信号量的notify()或notifyAll()来唤醒它。

线程在不同时刻有不同的状态，正在被执行时，即占有CPU时
我们称之为Running状态。那么其它的状态线程自然是不能运行啦。
很可能有多个线程都不能运行吧，但它们不能运行的原因却是各不相同的。
那么由于相同原因不能运行的线程就会存在一个“池pool”中。
由于虚拟机线程调度而不运行的，处于 Runnable池中，表示万事俱备，
只差CPU，由于使用synchronized而阻塞的线程就会在对象锁
(object 's lock pool)池中等待。而同步的方法中调用wait()后，线程则会
在wait池中等待。这里要注意了，首先wait()方法能得到执行说明当前线程
正在运行（在Running状态），从而说明它肯定拥有对象锁；第二，调用
wait()方法进入阻塞状态时，当前线程将释放对象锁（！！）第三，
在notify()或notifyAll()方法唤醒此线程时，它将进入 object 's lock pool
  池中等待，以重新获得对象锁。状态图如下所示。
                                       Schedule
(Runnable)          <------------->    (Running)
            ^                                                    |       \
            |                                                    |          --\
            |                               synchronized          wait() --must hav lock
      acquire lock                                     |                \ release lock
            |                                                    |                   \
            |                                                    |                      \
            |                   (Blocked in)       |                (Bolcked in )
               ----------( object 's ) <----                ( object 's    )
                                    ( lock pool) <---------- ( wait pool )
                                                                  notify()
我认为是这样这样理解可以更好回答你这个问题按照这个思路想下去就可以理解了

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2