很多资料上都说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. }
    

复制代码

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

     朋友你的同步块是为了保证在t线程修改b的值时，其他线程不会来抢着修改，不然就会出现混乱，但是它并不能阻止其他线程去修改b的值。
你对b做了两次修改，一个线程将其修改为500，另一个线程将其修改成200。正常情形下，最终结果只可能是500或200，不会是100。说道这里我相信你比较明白了。b=500先执行的话，输出的就是200，反之亦然。

其实就是m1和主线程抢CPU执行权，不是m2进了m1，是代码在m1里还没执行完就被主线程抢到了，理所应当的就执行了m2的内容

请勿复制他人帖子，技术分不是入学的门槛而是为了帮助大家学习而存在的。

请勿再次发此类帖子了！

此贴就关闭了。此后如有再次发现直接封禁处理，请看到此贴的会员也加以注意。