很多资料上都说sleep 不会释放锁.我做了一个小例子,感觉有点晕

1. public class Test2 extends Thread {
   
2. 
   
3.         int b = 100;
   
4. 
   
5.         public void m1() throws InterruptedException {
   
6.                
   
7.                 System.out.println("m1 enter..");
   
8.                 synchronized (this) {
   
9.                         System.out.println("m1 enter synchronized block..");
   
10.                         b = 200;
    
11.                         Thread.sleep(5000);//?
    
12.                         System.out.println("b= " + b);
    
13.                 }
    
14.         }
    
15. 
    
16.         public  void m2() throws InterruptedException {
    
17.                 System.out.println("m2 enter..");
    
18.                 b = 500;
    
19.         }
    
20. 
    
21.         public void run() {
    
22.                 System.out.println("runing ...");
    
23.                 try {
    
24.                         m1();
    
25.                 } catch (InterruptedException e) {
    
26. 
    
27.                         e.printStackTrace();
    
28.                 }
    
29.         }
    
30. 
    
31.         public static void main(String[] args) throws InterruptedException {
    
32.                 Test2 t = new Test2();
    
33.                  
    
34.                 t.start();
    
35. 
    
36.                 Thread.sleep(2000);
    
37.                 t.m2();
    
38. 
    
39.         }
    
40. 
    
41. }
    
42. 
    

复制代码

输出结果如下:
runing ...
m1 enter..
m1 enter synchronized block..
m2 enter..
b= 500
我怎么感觉最后一行输出 应该是 100呢.还有m1方法进入同步块后居然还执行m2方法了是怎么回事?
如果给m2方法 加 synchronized,结果是我想要的,想不明白....

m2 方法是由 主线程负责执行的
你的 新建线程执行进入代码块后，他将 this 锁关闭其他线程不能进入 有this 锁的 同步代码块

但是你的 m2（）方法并没有加上同步，更没有this同步锁， 它 当然是可执行的

你想要的效果是 新线程进入同步块后 其他线程不能操作 b 吧?
那就应该把有 b 操作的地方加上同步，并且使用 this 锁
：synchronized (this) {
         b = 500;
}

我用你的代码做的实验：
你的源码结果为：
runing ...
m1 enter..
m1 enter synchronized block..
m2 enter..
b= 500
过程是：
1，主线程启动
2，调用start方法==》runing ...
3，主线程休眠2秒
4，调用m1（） ==》m1 enter..
5，m1中进入同步代码块 ==》m1 enter synchronized block..
6，m1中 b=200，睡眠5秒==》
7，主线程苏醒，调用m2()方法 b=500 ==》m2 enter..
8，m1苏醒==》打印b= 500

如果给m2方法 加 synchronized，我的结果是          
runing ...
m1 enter..
m1 enter synchronized block..
b= 200
m2 enter..
过程是：
1，主线程启动
2，调用start方法==》runing ...
3，主线程休眠2秒
4，调用m1（） ==》m1 enter..
5，m1中进入同步代码块 ==》m1 enter synchronized block..
6，m1中 b=200，睡眠5秒==》但是不会释放对象锁
7，主线程苏醒，调用m2()方法 （但是没有锁不能运行）
8，m1苏醒==》打印b= 200
9，m2（）获得锁运行==》m2 enter..

楼主，  Thread.sleep是让当前线程休眠一段时间      
public static void main(String[] args) throws InterruptedException {
                Test2 t = new Test2();
                 
                t.start();//这里t线程启动调用run方法，runing ...，run中调用了M1方法，打印m1 enter..，进入锁之后，打印m1 enter synchronized block..
再往下运行时，楼主调用了一次Thread.sleep方法，此时休眠的是t线程，t线程休眠后，main函数获取cup执行权

                Thread.sleep(2000);//main函数运行到这里时，调用了Thread.sleep，此时休眠的就是main函数了，主线程休眠的时间为2秒，t线程休眠的时间为5秒，因此主线程先获取执行权
                t.m2();//就调用了m2方法，打印m2 enter.. b= 500

        }
如果想要验证sleep的作用，应该创建两个线程，同时去调用m1方法，这样就可以看到锁是不是被释放了。

rslheima 发表于 2012-7-19 21:06
我用你的代码做的实验：
你的源码结果为：
runing ...

清楚明白，收藏了...