刚才在网上看到一道关于同步线程的笔试题，
自己整理如下

1. package Luntai;
   
2. 
   
3. //直接将此类定义为线程类
   
4. public class Test1 implements Runnable {
   
5. //        一个成员变量
   
6.         int b = 100;
   
7.         
   
8. //        不多说，重写run()
   
9.         public void run() {
   
10.                 m1();
    
11.         }
    
12.         
    
13.         public synchronized void m1() {
    
14.                 b = 1000;
    
15. //                等个5秒
    
16.                 try {
    
17.                         Thread.sleep(5000);
    
18.                 } catch (InterruptedException e) {
    
19.                         e.printStackTrace();
    
20.                 }
    
21.                 System.out.println("m1方法输出" + b);
    
22.         }
    
23.         
    
24.         public void m2() {
    
25.                 System.out.println("m2方法输出" + b);
    
26.         }
    
27.         
    
28.         public static void main(String[] args) {
    
29.                 Test1 mt = new Test1();
    
30.                 Thread tt = new Thread(mt);
    
31. //                用tt线程调m1方法
    
32.                 tt.start();
    
33.                
    
34. //                等个半秒，确保tt拿到了同步锁
    
35.                 try {
    
36.                         Thread.sleep(500);
    
37.                 } catch (InterruptedException e) {
    
38.                         e.printStackTrace();
    
39.                 }
    
40.                
    
41. //                然后用主线程调用m2方法               
    
42.                 mt.m2();
    
43.                
    
44.         }
    
45. }

复制代码

问，程序的输出结果？

自己分析了下有3种可能
1.
m2方法输出1000
m1方法输出1000

2.
m2方法输出100
m1方法输出1000

3.在m1执行完前m2不能执行,所以是
m1方法输出1000
m2方法输出1000


由于同步学的比较久了，很多都忘了，坐等详见，另外自己查资料中
自我补充：如果方法m2也加上synchronized关键字，答案又是怎么样的呢？

我看三种都有可能，但那时数学上的概率，计算机实现不了

没人解答，自我解答
查了下资料+温习了一下，现整理关于同步线程的一些知识点如下：1.
synchronized锁定的不是方法，而是当前对象，包括成员变量
什么时候解开呢？就是在加锁的大括号执行完后
wait()和sleep()最大的区别：sleep()方法不会释放当前对象的同步锁，而wait()方法会释放同步锁

2.
死锁的预防：
a.逻辑上的预防
b.加大锁的粒度，也就是大家要锁的对象范围

3.
Thread.sleep()睡眠的是当前正在执行的线程

4.
在一个线程正在执行一个对象的synchronized的方法时，其他线程仍然可以执行这个对象的非synchronized方法(这个就是说，在执行同步方法时，需要得到这个对象的同步锁；但对于非同步方法，就没这个要求了)

5.
在一个对象调用notify()方法的时候，当前对象的监听线程正持有同步锁，因此，虽然其他线程被叫醒了，但仍然需要等这个线程执行完synchronized语句块后，释放锁后，其他线程才能公平争夺同步锁。
也就是说，调用wait()语句后，马上释放锁，后面的语句都不会被执行(直到被叫醒)
而在notify()语句后面，一直会执行完synchronized语句块后才会释放同步锁

--------------------------------------------------------------------------------------------------------------
那么，这题显而易见，用到了第4个知识点
解释一下：线程 tt.start();在调用m1方法时取得了这个对象的同步锁，并且将b的值改为1000，然后睡了5秒。
在线程tt睡觉的时候，主线程调用了m2方法，由于m2方法并不是同步方法，所以主线程不需要去获得对象同步锁就能执行，所以先输出m2方法里的语句
也是就是:“m2方法输出1000”
然后tt线程睡醒了，接着再输出"m1方法输出1000"，也就是原题的答案是第一种可能。

然后分析我自己的补充题：
前面一样，但是在主线程调用m2方法时，由于m2方法也变成了同步方法，所以主线程需要取得当前对象的同步锁才能执行m2方法，而此时的同步锁
被正在睡觉的m1霸占着，所以，m2方法只能等m1执行完释放同步锁后才能接着执行
也就是输出的答案是
m1方法输出1000
m2方法输出1000

1楼的兄弟可能没看仔细，这个不是概率问题，不信你自己去运行，结果都是一样的

楼上是我自己的一些分析，如有不当，欢迎指正如果没什么疑问的话，我晚上结题了