本页主题: 对synchronized(this)的一些理解 打印 | 加为IE收藏 | 复制链接 | 收藏主题 | 上一主题 | 下一主题

Mike
群熵工程师
级别: 管理员


精华: 7
发帖: 951
威望: 714 点
金钱: 6601 RMB
贡献值: 0 点
好评度: 611 点
在线时间:1405(小时)
注册时间:2003-11-28
最后登录:2018-04-23

 对synchronized(this)的一些理解

转载。只要把这几个例子搞明白了,基本上synchronized的用法可以说没问题了。做多线程开发不能不看!

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

四、第三个例子同样适用其它同步代码块或同步方法。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分或同步方法的访问都被暂时阻塞。

五、以上规则对其它对象锁同样适用.

举例说明:
一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

package ths;

public class Thread1 implements Runnable {
public void run() {
synchronized(this) {
for (int i = 0; i < 5; i++) {
System.out.println(Thread.currentThread().getName() + \" synchronized loop \" + i);
}
}
}
public static void main(String[] args) {
Thread1 t1 = new Thread1();
Thread ta = new Thread(t1, \"A\");
Thread tb = new Thread(t1, \"B\");
ta.start();
tb.start();
}
}

结果:
A synchronized loop 0
A synchronized loop 1
A synchronized loop 2
A synchronized loop 3
A synchronized loop 4
B synchronized loop 0
B synchronized loop 1
B synchronized loop 2
B synchronized loop 3
B synchronized loop 4

二、然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

package ths;

public class Thread2 {
public void m4t1() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + \" : \" + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
}
public void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + \" : \" + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}
public static void main(String[] args) {
final Thread2 myt2 = new Thread2();
Thread t1 = new Thread(
new Runnable() {
public void run() {
myt2.m4t1();
}
}, \"t1\"
);
Thread t2 = new Thread(
new Runnable() {
public void run() {
myt2.m4t2();
}
}, \"t2\"
);
t1.start();
t2.start();
}
}

结果:
t1 : 4
t2 : 4
t1 : 3
t2 : 3
t1 : 2
t2 : 2
t1 : 1
t2 : 1
t1 : 0
t2 : 0

三、尤其关键的是,当一个线程访问object的一个synchronized(this)同步代码块时,其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

//修改Thread2.m4t2()方法:
public void m4t2() {
synchronized(this) {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + \" : \" + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

}

结果:

t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

四、第三个例子同样适用其它同步代码块。也就是说,当一个线程访问object的一个synchronized(this)同步代码块时,它就获得了这个object的对象锁。结果,其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

//修改Thread2.m4t2()方法如下:

public synchronized void m4t2() {
int i = 5;
while( i-- > 0) {
System.out.println(Thread.currentThread().getName() + \" : \" + i);
try {
Thread.sleep(500);
} catch (InterruptedException ie) {
}
}
}

结果:
t1 : 4
t1 : 3
t1 : 2
t1 : 1
t1 : 0
t2 : 4
t2 : 3
t2 : 2
t2 : 1
t2 : 0

五、以上规则对其它对象锁同样适用:

package ths;

public class Thread3 {
class Inner {
    private void m4t1() {
        int i = 5;
        while(i-- > 0) {
              System.out.println(Thread.currentThread().getName() + \" : Inner.m4t1()=\" + i);
              try {
                  Thread.sleep(500);
              } catch(InterruptedException ie) {
              }
        }
    }
    private void m4t2() {
        int i = 5;
        while(i-- > 0) {
              System.out.println(Thread.currentThread().getName() + \" : Inner.m4t2()=\" + i);
              try {
                  Thread.sleep(500);
              } catch(InterruptedException ie) {
              }
        }
    }
}
    private void m4t1(Inner inner) {
        synchronized(inner) { //使用对象锁
              inner.m4t1();
        }
    }
    private void m4t2(Inner inner) {
        inner.m4t2();
    }
    public static void main(String[] args) {
        final Thread3 myt3 = new Thread3();
        final Inner inner = myt3.new Inner();
        Thread t1 = new Thread(
              new Runnable() {
              public void run() {
                  myt3.m4t1(inner);
              }
              }, \"t1\"
        );
        Thread t2 = new Thread(
              new Runnable() {
              public void run() {
                  myt3.m4t2(inner);
              }
              }, \"t2\"
        );
        t1.start();
        t2.start();
    }
}

结果:

尽管线程t1获得了对Inner的对象锁,但由于线程t2访问的是同一个Inner中的非同步部分。所以两个线程互不干扰。

t1 : Inner.m4t1()=4
t2 : Inner.m4t2()=4
t1 : Inner.m4t1()=3
t2 : Inner.m4t2()=3
t1 : Inner.m4t1()=2
t2 : Inner.m4t2()=2
t1 : Inner.m4t1()=1
t2 : Inner.m4t2()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=0

现在在Inner.m4t2()前面加上synchronized:

private synchronized void m4t2() {
    int i = 5;
    while(i-- > 0) {
        System.out.println(Thread.currentThread().getName() + \" : Inner.m4t2()=\" + i);
        try {
              Thread.sleep(500);
        } catch(InterruptedException ie) {
        }
    }
}

结果:

尽管线程t1与t2访问了同一个Inner对象中两个毫不相关的部分,但因为t1先获得了对Inner的对象锁,所以t2对Inner.m4t2()的访问也被阻塞,因为m4t2()是Inner中的一个同步方法。

t1 : Inner.m4t1()=4
t1 : Inner.m4t1()=3
t1 : Inner.m4t1()=2
t1 : Inner.m4t1()=1
t1 : Inner.m4t1()=0
t2 : Inner.m4t2()=4
t2 : Inner.m4t2()=3
t2 : Inner.m4t2()=2
t2 : Inner.m4t2()=1
t2 : Inner.m4t2()=0

From: http://www.54bk.com/more.asp?name=kevindeng&id=2239&commentid=14871
顶端 Posted: 05-11-21 12:19 | [楼 主]
Mike
群熵工程师
级别: 管理员


精华: 7
发帖: 951
威望: 714 点
金钱: 6601 RMB
贡献值: 0 点
好评度: 611 点
在线时间:1405(小时)
注册时间:2003-11-28
最后登录:2018-04-23

 还有一个形象解释,也不错

图片:
图例说明:左边带麻点的是synchronized方法或代码块。右边的是普通方法。黄色的是该对象(也称之为实例)的key,每个对象有且只有一个key。只有拥有该key的线程才能进入synchronized方法。

打个比方:一个object就像一个大房子,大门永远打开。房子里有很多房间(也就是方法)。这些房间有上锁的(synchronized方法),和不上锁之分(普通方法)。房门口放着一把钥匙(key),这把钥匙可以打开所有上锁的房间。另外我把所有想调用该对象方法的线程比喻成想进入这房子某个房间的人。所有的东西就这么多了,下面我们看看这些东西之间如何作用的。

在此我们先来明确一下我们的前提条件。该对象至少有一个synchronized方法,否则这个key还有啥意义。当然也就不会有我们的这个主题了。

一个人想进入某间上了锁的房间,他来到房子门口,看见钥匙在那儿(说明暂时还没有其他人要使用上锁的房间)。于是他走上去拿到了钥匙,并且按照自己的计划使用那些房间。注意一点,他每次使用完一次上锁的房间后会马上把钥匙还回去。即使他要连续使用两间上锁的房间,中间他也要把钥匙还回去,再取回来。

因此,普通情况下钥匙的使用原则是:“随用随借,用完即还。”

这时其他人可以不受限制的使用那些不上锁的房间,一个人用一间可以,两个人用一间也可以,没限制。但是如果当某个人想要进入上锁的房间,他就要跑到大门口去看看了。有钥匙当然拿了就走,没有的话,就只能等了。

要是很多人在等这把钥匙,等钥匙还回来以后,谁会优先得到钥匙?Not guaranteed。象前面例子里那个想连续使用两个上锁房间的家伙,他中间还钥匙的时候如果还有其他人在等钥匙,那么没有任何保证这家伙能再次拿到。(JAVA规范在很多地方都明确说明不保证,象Thread.sleep()休息后多久会返回运行,相同优先权的线程那个首先被执行,当要访问对象的锁被释放后处于等待池的多个线程哪个会优先得到,等等。我想最终的决定权是在JVM,之所以不保证,就是因为JVM在做出上述决定的时候,绝不是简简单单根据一个条件来做出判断,而是根据很多条。而由于判断条件太多,如果说出来可能会影响JAVA的推广,也可能是因为知识产权保护的原因吧。SUN给了个不保证就混过去了。无可厚非。但我相信这些不确定,并非完全不确定。因为计算机这东西本身就是按指令运行的。即使看起来很随机的现象,其实都是有规律可寻。学过计算机的都知道,计算机里随机数的学名是伪随机数,是人运用一定的方法写出来的,看上去随机罢了。另外,或许是因为要想弄的确定太费事,也没多大意义,所以不确定就不确定了吧。)

再来看看同步代码块。和同步方法有小小的不同。

1.从尺寸上讲,同步代码块比同步方法小。你可以把同步代码块看成是没上锁房间里的一块用带锁的屏风隔开的空间。

2.同步代码块还可以人为的指定获得某个其它对象的key。就像是指定用哪一把钥匙才能开这个屏风的锁,你可以用本房的钥匙;你也可以指定用另一个房子的钥匙才能开,这样的话,你要跑到另一栋房子那儿把那个钥匙拿来,并用那个房子的钥匙来打开这个房子的带锁的屏风。

记住你获得的那另一栋房子的钥匙,并不影响其他人进入那栋房子没有锁的房间。

为什么要使用同步代码块呢?我想应该是这样的:首先对程序来讲同步的部分很影响运行效率,而一个方法通常是先创建一些局部变量,再对这些变量做一些操作,如运算,显示等等;而同步所覆盖的代码越多,对效率的影响就越严重。因此我们通常尽量缩小其影响范围。如何做?同步代码块。我们只把一个方法中该同步的地方同步,比如运算。

另外,同步代码块可以指定钥匙这一特点有个额外的好处,是可以在一定时期内霸占某个对象的key。还记得前面说过普通情况下钥匙的使用原则吗。现在不是普通情况了。你所取得的那把钥匙不是永远不还,而是在退出同步代码块时才还。

还用前面那个想连续用两个上锁房间的家伙打比方。怎样才能在用完一间以后,继续使用另一间呢。用同步代码块吧。先创建另外一个线程,做一个同步代码块,把那个代码块的锁指向这个房子的钥匙。然后启动那个线程。只要你能在进入那个代码块时抓到这房子的钥匙,你就可以一直保留到退出那个代码块。也就是说你甚至可以对本房内所有上锁的房间遍历,甚至再sleep(10*60*1000),而房门口却还有1000个线程在等这把钥匙呢。很过瘾吧。

在此对sleep()方法和钥匙的关联性讲一下。一个线程在拿到key后,且没有完成同步的内容时,如果被强制sleep()了,那key还一直在它那儿。直到它再次运行,做完所有同步内容,才会归还key。记住,那家伙只是干活干累了,去休息一下,他并没干完他要干的事。为了避免别人进入那个房间把里面搞的一团糟,即使在睡觉的时候他也要把那唯一的钥匙戴在身上。

最后,也许有人会问,为什么要一把钥匙通开,而不是一个钥匙一个门呢?我想这纯粹是因为复杂性问题。一个钥匙一个门当然更安全,但是会牵扯好多问题。钥匙的产生,保管,获得,归还等等。其复杂性有可能随同步方法的增加呈几何级数增加,严重影响效率。

这也算是一个权衡的问题吧。为了增加一点点安全性,导致效率大大降低,是多么不可取啊。

From: http://www.54bk.com/more.asp?name=czp&id=2097
顶端 Posted: 05-11-21 12:47 | 1 楼
Mike
群熵工程师
级别: 管理员


精华: 7
发帖: 951
威望: 714 点
金钱: 6601 RMB
贡献值: 0 点
好评度: 611 点
在线时间:1405(小时)
注册时间:2003-11-28
最后登录:2018-04-23

 一个synchronized使用不当导致多进程互锁的例子

这个程序之所以能正常运行,是因为每个thread都非常之快地运行结束。

public class SyncTest{
public static void main(String[] args){
final StringBuffer s1=new StringBuffer();
final StringBuffer s2=new StringBuffer();
new Thread() {
public void run(){ //只有拥有s1的锁,才可以执行后面的代码,
  synchronized(s1){   //现在当前线程有S1的锁
    s1.append("A");  
    synchronized(s2){   // 当前线程有S2的锁
    s2.append("B");
    System.out.print(s1);
    System.out.print(s2);
    }  
  }
  }
}.start(); // 如果足够快的话,当前线程结束运行,释放S1和S2的锁。

new Thread(){ //此时上一个线程可能已经结束,S1和S2的锁都已经释放。
public void run(){
  synchronized(s2){ //当前线程有S2的锁
    s2.append("C");
synchronized(s1){ //当前线程有S2的锁
  s1.append("D");
  System.out.println(s2);
  System.out.println(s1);
  }
}
}
}.start();
}
}


  你可以试验一下,在两个线程中各加上几个yield(),当第一个线程刚刚得到S1时,第二个线程已经得到了S2的锁。然后第一个线程在等S2,第二个线程等S1,就会形成死锁。
  Java本身并没有提供避免这种死锁的方法,只有靠程序员自己去注意了。因此,良好的程序设计方法是,(尽量)保持同样的顺序去获取锁。
顶端 Posted: 05-11-21 13:07 | 2 楼
Mike
群熵工程师
级别: 管理员


精华: 7
发帖: 951
威望: 714 点
金钱: 6601 RMB
贡献值: 0 点
好评度: 611 点
在线时间:1405(小时)
注册时间:2003-11-28
最后登录:2018-04-23

 wait/notify机制

通常,多线程之间需要协调工作。例如,浏览器的一个显示图片的线程displayThread想要执行显示图片的任务,必须等待下载线程downloadThread将该图片下载完毕。如果图片还没有下载完,displayThread可以暂停,当downloadThread完成了任务后,再通知displayThread“图片准备完毕,可以显示了”,这时,displayThread继续执行。



以上逻辑简单的说就是:如果条件不满足,则等待。当条件满足时,等待该条件的线程将被唤醒。在Java中,这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。例如:



synchronized(obj) {
  while(!condition) {
    obj.wait();
  }
  obj.doSomething();
}



当线程A获得了obj锁后,发现条件condition不满足,无法继续下一处理,于是线程A就wait()。



在另一线程B中,如果B更改了某些条件,使得线程A的condition条件满足了,就可以唤醒线程A:



synchronized(obj) {
  condition = true;
  obj.notify();
}



需要注意的概念是:



# 调用obj的wait(), notify()方法前,必须获得obj锁,也就是必须写在synchronized(obj) {...} 代码段内。



# 调用obj.wait()后,线程A就释放了obj的锁,否则线程B无法获得obj锁,也就无法在synchronized(obj) {...} 代码段内唤醒A。



# 当obj.wait()方法返回后,线程A需要再次获得obj锁,才能继续执行。



# 如果A1,A2,A3都在obj.wait(),则B调用obj.notify()只能唤醒A1,A2,A3中的一个(具体哪一个由JVM决定)。



# obj.notifyAll()则能全部唤醒A1,A2,A3,但是要继续执行obj.wait()的下一条语句,必须获得obj锁,因此,A1,A2,A3只有一个有机会获得锁继续执行,例如A1,其余的需要等待A1释放obj锁之后才能继续执行。



# 当B调用obj.notify/notifyAll的时候,B正持有obj锁,因此,A1,A2,A3虽被唤醒,但是仍无法获得obj锁。直到B退出synchronized块,释放obj锁后,A1,A2,A3中的一个才有机会获得锁继续执行。
顶端 Posted: 05-11-21 14:11 | 3 楼
帖子浏览记录 版块浏览记录
群熵信息 - 技术讨论区 » 面向WEB的Java技术

Total 0.021146(s) query 5, Time now is:08-22 15:43, Gzip enabled
Powered by PHPWind v6.3.2 Certificate Code © 2003-08 PHPWind.com Corporation

上海服务器租用 杭州世导双线服务器托管 云主机 VPS