java wait和notify及 synchronized sleep 总结

java 中线程我一直弄不清线程锁等 所以写了一些例子验证看法：

在这之前先看下API中wait中的解释:

wait：方法来之java.lang.Objetc

方法翻译：在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。并释放所有同步锁 //当前线程必须拥有此对象监视器。 （sleep不会释放）

sleep:休眠当前线程 并且不释放同步锁

notify:唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。线程通过调用其中一个 wait 方法，在对象的监视器上等待。该方法不会释放调用线程的同步锁

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

那么实验1:

大家看到线程A B C分别锁了 Test中 s1 s2 s3  

猜想：因为s1 s2 s3 不是同一对象所以会交替打印 我是线程A 线程B 线程C

[java]  view plain  copy

1. package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 ="";  
5.     static String s2 ="";  
6.     static String s3 ="";  
7.     public static void main(String[] args) {  
8.         A a = new A();  
9.         B b = new B();  
10.         C c = new C();  
11.         c.start();  
12.         b.start();  
13.         a.start();  
14.           
15.     }  
16. }  
17. class A extends Thread{  
18.   
19.     @Override  
20.     public void run() {  
21.         synchronized (Test.s1) {  
22.             while (true) {  
23.                 try {  
24.                     sleep(1000);  
25.                 } catch (InterruptedException e) {  
26.                     // TODO Auto-generated catch block  
27.                     e.printStackTrace();  
28.                 }  
29.                 System.out.println("我是线程A");  
30.             }  
31.         }  
32.     }  
33.       
34. }  
35. class B extends Thread{  
36.     @Override  
37.     public void run() {  
38.         synchronized (Test.s2) {  
39.             while (true) {  
40.                 try {  
41.                     sleep(1000);  
42.                 } catch (InterruptedException e) {  
43.                     // TODO Auto-generated catch block  
44.                     e.printStackTrace();  
45.                 }  
46.                 System.out.println("我是线程B");  
47.             }  
48.         }  
49.     }  
50. }  
51. class C extends Thread{  
52.     @Override  
53.     public void run() {  
54.         synchronized (Test.s3) {  
55.             while (true) {  
56.                 try {  
57.                     sleep(1000);  
58.                 } catch (InterruptedException e) {  
59.                     // TODO Auto-generated catch block  
60.                     e.printStackTrace();  
61.                 }  
62.                 System.out.println("我是线程C");  
63.             }  
64.         }  
65.     }  
66. }  

输出结果:

我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C
我是线程C

结果发现打印的是 全是 线程C

原因 S1 S2 S3指向同一常量池 所以锁的是同一内存区 所以 static String s1 =new String()  static String s2 =new String()  static String s3 =new String()  的时候他们会交替打印

那么实验2:

[python]  view plain  copy

1. package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 =new String();  
5.     static String s2 =new String();  
6.     static String s3 =new String();  
7.     public static void main(String[] args) {  
8.         A a = new A();  
9.         B b = new B();  
10.         C c = new C();  
11.         c.start();  
12.         b.start();  
13.         a.start();  
14.           
15.     }  
16. }  
17. class A extends Thread{  
18.  
19.     @Override  
20.     public void run() {  
21.         synchronized (Test.s1) {  
22.             while (true) {  
23.                 try {  
24.                     sleep(1000);  
25.                 } catch (InterruptedException e) {  
26.                     // TODO Auto-generated catch block  
27.                     e.printStackTrace();  
28.                 }  
29.                 System.out.println("我是线程A");  
30.             }  
31.         }  
32.     }  
33.       
34. }  
35. class B extends Thread{  
36.     @Override  
37.     public void run() {  
38.         synchronized (Test.s2) {  
39.             while (true) {  
40.                 try {  
41.                     sleep(1000);  
42.                 } catch (InterruptedException e) {  
43.                     // TODO Auto-generated catch block  
44.                     e.printStackTrace();  
45.                 }  
46.                 System.out.println("我是线程B");  
47.             }  
48.         }  
49.     }  
50. }  
51. class C extends Thread{  
52.     @Override  
53.     public void run() {  
54.         synchronized (Test.s3) {  
55.             while (true) {  
56.                 try {  
57.                     sleep(1000);  
58.                 } catch (InterruptedException e) {  
59.                     // TODO Auto-generated catch block  
60.                     e.printStackTrace();  
61.                 }  
62.                 System.out.println("我是线程C");  
63.             }  
64.         }  
65.     }  
66. }  

输出结果：

我是线程A
我是线程C
我是线程B
我是线程A
我是线程C
我是线程B
我是线程A
我是线程C
我是线程B
我是线程A
我是线程C
我是线程A
我是线程B
我是线程C
我是线程B
我是线程A

结论：证明实验一结论是正确的

实验三：

 wait是否要在synchronized方法块中？

[java]  view plain  copy

1. public class Test {  
2.     static String s1 =new String();  
3.     static String s2 =new String();  
4.     static String s3 =new String();  
5.     public static void main(String[] args) {  
6.         A a = new A();  
7.         B b = new B();  
8.         C c = new C();  
9.         a.start();  
10.           
11.     }  
12. }  
13. class A extends Thread{  
14.   
15.     @Override  
16.     public void run() {  
17. //      synchronized (Test.s1) {  
18.             while (true) {  
19.                 try {  
20.                     Test.s1.wait();  
21.                 } catch (InterruptedException e1) {  
22.                     // TODO Auto-generated catch block  
23.                     e1.printStackTrace();  
24.                 }  
25.                 try {  
26.                     sleep(1000);  
27.                 } catch (InterruptedException e) {  
28.                     // TODO Auto-generated catch block  
29.                     e.printStackTrace();  
30.                 }  
31.                 System.out.println("我是线程A");  
32.             }  
33. //      }  
34.     }  

输出结果:异常

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Unknown Source)
    at com.fmy.test.A.run(Test.java:22)

结论： wait是要在synchronized方法块中

实验四： notify是否要在synchronized方法块中

与实验三差不多 所以不贴出代码 

结果:notify是否要在synchronized方法块中

实验五： 某个线程没有X的对象锁调用 X.WAIT() 是否会让该对象阻塞 或者其他拥有 X对象锁的线程阻塞

[java]  view plain  copy

1.     package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 =new String();  
5.     static String s2 =new String();  
6.     static String s3 =new String();  
7.     static String s4 =new String();  
8.     public static void main(String[] args) {  
9.         A a = new A();  
10.         B b = new B();  
11.         C c = new C();  
12.         a.start();  
13.         b.start();  
14.           
15.     }  
16. }  
17. class A extends Thread{  
18.   
19.     @Override  
20.     public void run() {  
21.         synchronized (Test.s4) {  
22.             while (true) {  
23.                 try {  
24.                     Test.s2.wait();  
25.                 } catch (Exception e1) {  
26.                     // TODO Auto-generated catch block  
27.                     e1.printStackTrace();  
28.                 }  
29.                 try {  
30.                     sleep(1000);  
31.                 } catch (InterruptedException e) {  
32.                     // TODO Auto-generated catch block  
33.                     e.printStackTrace();  
34.                 }  
35.                 System.out.println("我是线程A");  
36.             }  
37.         }  
38.     }  
39.       
40. }  
41. class B extends Thread{  
42.     @Override  
43.     public void run() {  
44.         synchronized (Test.s2) {  
45.             while (true) {  
46.                 try {  
47.                     sleep(1000);  
48.                 } catch (InterruptedException e) {  
49.                     // TODO Auto-generated catch block  
50.                     e.printStackTrace();  
51.                 }  
52.                 System.out.println("我是线程B");  
53.             }  
54.         }  
55.     }  
56. }  

输出结果：java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Unknown Source)
    at com.fmy.test.A.run(Test.java:24)
java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Unknown Source)
    at com.fmy.test.A.run(Test.java:24)
我是线程A
我是线程B
我是线程B
我是线程A
java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Unknown Source)
    at com.fmy.test.A.run(Test.java:24)
我是线程A
我是线程B
我是线程B
我是线程A

结论：不能锁住当前线程和其他拥有该对象锁的线程并且会报异常 所以：当你想阻塞某个线程的时候请在某个线程中调用wait方法 并且对象拥有该锁

实验六： 某个线程没有X对象锁调用notify（）可以唤醒其他被锁的对象吗？

[java]  view plain  copy

1. package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 =new String();  
5.     static String s2 =new String();  
6.     static String s3 =new String();  
7.     static String s4 =new String();  
8.     public static void main(String[] args) {  
9.         A a = new A();  
10.         B b = new B();  
11.         C c = new C();  
12.         a.start();  
13.         b.start();  
14.           
15.     }  
16. }  
17. class A extends Thread{  
18.   
19.     @Override  
20.     public void run() {  
21.         synchronized (Test.s4) {  
22.             while (true) {  
23.                 try {  
24.                     sleep(1000);  
25.                     Test.s2.notify();  
26.                 } catch (Exception e1) {  
27.                     // TODO Auto-generated catch block  
28.                     e1.printStackTrace();  
29.                 }  
30.                 try {  
31.                     sleep(1000);  
32.                 } catch (InterruptedException e) {  
33.                     // TODO Auto-generated catch block  
34.                     e.printStackTrace();  
35.                 }  
36.                 System.out.println("我是线程A");  
37.             }  
38.         }  
39.     }  
40.       
41. }  
42. class B extends Thread{  
43.     @Override  
44.     public void run() {  
45.         synchronized (Test.s2) {  
46.             try {  
47.                 Test.s2.wait();  
48.             } catch (InterruptedException e1) {  
49.                 // TODO Auto-generated catch block  
50.                 e1.printStackTrace();  
51.             }  
52.             while (true) {  
53.                 try {  
54.                     sleep(1000);  
55.                 } catch (InterruptedException e) {  
56.                     // TODO Auto-generated catch block  
57.                     e.printStackTrace();  
58.                 }  
59.                 System.out.println("我是线程B");  
60.             }  
61.         }  
62.     }  
63. }  

输出结果：java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)
    at com.fmy.test.A.run(Test.java:25)
我是线程A
java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)
    at com.fmy.test.A.run(Test.java:25)
我是线程A
java.lang.IllegalMonitorStateException
    at java.lang.Object.notify(Native Method)
    at com.fmy.test.A.run(Test.java:25)
我是线程A

结论：一个对象没有X的对象锁使用了notify将不会唤醒其他线程使用了X.wait导致的阻塞

实验七：wait会是释放线所有该线程占有的锁吗？

[java]  view plain  copy

1. <pre name="code" class="java">package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 =new String();  
5.     static String s2 =new String();  
6.     static String s3 =new String();  
7.     static String s4 =new String();  
8.     public static void main(String[] args) {  
9.         A a = new A();  
10.         B b = new B();  
11.         C c = new C();  
12.         a.start();  
13.         b.start();  
14.           
15.     }  
16. }  
17. class A extends Thread{  
18.   
19.     @Override  
20.     public void run() {  
21.         synchronized (Test.s2) {  
22.             synchronized (Test.s1) {  
23.                 while (true) {  
24.                     try {  
25.                         System.out.println("我是A让自己阻塞");  
26.                         Test.s2.wait();  
27.                     } catch (Exception e1) {  
28.                         // TODO Auto-generated catch block  
29.                         e1.printStackTrace();  
30.                     }  
31.                     try {  
32.                         sleep(1000);  
33.                     } catch (InterruptedException e) {  
34.                         // TODO Auto-generated catch block  
35.                         e.printStackTrace();  
36.                     }  
37.                     System.out.println("我是线程A");  
38.                 }  
39.             }  
40.               
41.         }  
42.     }  
43.       
44. }  
45. class B extends Thread{  
46.     @Override  
47.     public void run() {  
48.         synchronized (Test.s2) {  
49.             while (true) {  
50.                 try {  
51.                     sleep(1000);  
52.                 } catch (InterruptedException e) {  
53.                     // TODO Auto-generated catch block  
54.                     e.printStackTrace();  
55.                 }  
56.                 System.out.println("我是线程B");  
57.             }  
58.         }  
59.     }  
60. }  

输出结果：我是A让自己阻塞
我是线程B
我是线程B
我是线程B
我是线程B

结论：wait方法会释放线程的所有同步锁

实验八：sleep会是释放线所有该线程占有的锁吗？

[java]  view plain  copy

1. package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 =new String();  
5.     static String s2 =new String();  
6.     static String s3 =new String();  
7.     static String s4 =new String();  
8.     public static void main(String[] args) {  
9.         A a = new A();  
10.         B b = new B();  
11.         C c = new C();  
12.         a.start();  
13.         b.start();  
14.           
15.     }  
16. }  
17. class A extends Thread{  
18.   
19.     @Override  
20.     public void run() {  
21.         synchronized (Test.s2) {  
22.             synchronized (Test.s1) {  
23.                 while (true) {  
24.                     try {  
25.                         System.out.println("我是A让自己睡一下");  
26.                         sleep(1000);  
27.                     } catch (Exception e1) {  
28.                         // TODO Auto-generated catch block  
29.                         e1.printStackTrace();  
30.                     }  
31.                     try {  
32.                         sleep(1000);  
33.                     } catch (InterruptedException e) {  
34.                         // TODO Auto-generated catch block  
35.                         e.printStackTrace();  
36.                     }  
37.                     System.out.println("我是线程A");  
38.                 }  
39.             }  
40.               
41.         }  
42.     }  
43.       
44. }  
45. class B extends Thread{  
46.     @Override  
47.     public void run() {  
48.         synchronized (Test.s2) {  
49.             while (true) {  
50.                 try {  
51.                     sleep(1000);  
52.                 } catch (InterruptedException e) {  
53.                     // TODO Auto-generated catch block  
54.                     e.printStackTrace();  
55.                 }  
56.                 System.out.println("我是线程B");  
57.             }  
58.         }  
59.     }  
60. }  

输出结果：我是A让自己睡一下
我是线程A
我是A让自己睡一下
我是线程A
我是A让自己睡一下
我是线程A
我是A让自己睡一下

结论：sleep方法不会释放调用线程的同步锁

实验九：证明 和理解   notify():该方法不会释放调用线程的同步锁,只是会唤醒被wait()阻塞的线程

[java]  view plain  copy

1. <span style="color:#000000;">package com.fmy.test;  
2.   
3. public class Test {  
4.     static String s1 =new String();  
5.     static String s2 =new String();  
6.     static String s3 =new String();  
7.     static String s4 =new String();  
8.      static A a = null;  
9.       
10.     public static void main(String[] args) {  
11.         a  = new A();  
12.         B b = new B();  
13.         C c = new C();  
14.         a .start();  
15.         b.start();  
16.           
17.     }  
18. }  
19. class A extends Thread{  
20.   
21.     @Override  
22.     public void run() {  
23.           
24.         synchronized (Test.s1) {  
25.             System.out.println("我是A让自己阻塞");  
26.             try {  
27.                 Test.s1.wait();  
28.             } catch (InterruptedException e2) {  
29.                 // TODO Auto-generated catch block  
30.                 e2.printStackTrace();  
31.             }  
32.                 while (true) {  
33.                       
34.                     try {  
35.                         sleep(1000);  
36.                     } catch (InterruptedException e) {  
37.                         // TODO Auto-generated catch block  
38.                         e.printStackTrace();  
39.                     }  
40.                     System.out.println("我是线程A");  
41.                 }  
42.               
43.               
44.         }  
45.     }  
46.       
47. }  
48. class B extends Thread{  
49.     @Override  
50.     public void run() {  
51.         synchronized (Test.s1) {  
52.             while (true) {  
53.                 try {  
54.                     sleep(1000);//保证线程A先执行 到wait处  
55.                       
56.                 } catch (InterruptedException e) {  
57.                     // TODO Auto-generated catch block  
58.                     e.printStackTrace();  
59.                 }  
60.                 System.out.println("被阻塞后的A线程状态"+Test.a.getState());  
61.                 System.out.println("我是线程B");  
62.                 //唤醒A线程  
63.                 Test.s1.notify();  
64.                 System.out.println("被唤醒线程A的状态"+Test.a.getState());  
65.             }  
66.         }  
67.     }  
68. }</span>  

输出结果：我是A让自己阻塞
被阻塞后的A线程状态WAITING
我是线程B
被唤醒线程A的状态BLOCKED
被阻塞后的A线程状态BLOCKED
我是线程B
被唤醒线程A的状态BLOCKED
被阻塞后的A线程状态BLOCKED
我是线程B

结论：证实实验九。直到调用notify的线程结束或者自行放弃同步锁才能到被唤醒的线程执行。notify方法只会唤醒被阻塞的线程而已 并不会影响到调用此方法的线程所有状态和锁