Java多线程之synchronized

这里通过三个测试类阐述了synchronized应用的不同场景

首先是最基本的synchronized Method的使用

1. package com.jadyer.thread.sync;  
2.   
3. /** 
4.  * Synchronized Method Test 
5.  * @see =================================================================================================== 
6.  * @see 概述：Java中的每个对象都有一个锁(lock)或者叫做监视器(monitor) 
7.  * @see 说明：当synchronized关键字修饰一个方法时，则该方法为同步方法 
8.  * @see      当某个线程访问某个对象的synchronized方法时，则表示将该对象上锁 
9.  * @see      此时其它的任何线程，均无法访问该对象中的任何一个synchronized方法(但允许访问该对象中的非synchronized方法) 
10.  * @see      直到该线程所访问的synchronized方法执行完毕(或者抛出了异常)之后，该对象的锁才会被释放 
11.  * @see      此时其它的任何线程，才被允许访问该synchronized方法，或者是该对象中的其它synchronized方法 
12.  * @see =================================================================================================== 
13.  * @see 总结：如果一个对象有多个synchronized方法，某一时刻某个线程已经执行了该对象中的某一个synchronized方法 
14.  * @see      那么在该方法没有执行完毕之前，其它线程是无法访问该对象中的，包括该方法在内的，任何一个synchronized方法 
15.  * @see      重点在于判断Synchronized锁的是谁。如果该方法是静态的，则锁Class对象，否则锁的就是当前对象 
16.  * @see =================================================================================================== 
17.  * @see 补充：1)这只是针对多个线程操作同一个类的同一个对象的情况。www.linuxidc.com若多个线程操作同一个类的不同对象，则不存在这种情况 
18.  * @see      2)Java中的volatile变量也可以看作是一种"程度较轻的synchronized" 
19.  * @see        关于volatile的更多信息，请参考http://www.ibm.com/developerworks/cn/java/j-jtp06197.html 
20.  * @see 备注：实际项目中，用到的更多的还是JDK5.0开始推出的Java并发包，即java.util.concurrent包里面的工具类 
21.  * @see      java.util.concurrent可以非常细粒度的实现并发。比如线程访问到了一个已被锁的对象，它可以让这个线程等到10秒 
22.  * @see      10秒后如果该对象仍未被解锁，那么就可以返回给用户超时的提示等，而如果使用synchronized则是无法这么精确控制的 
23.  * @see =================================================================================================== 
24.  * @see 注意：1)当synchronized方法执行完或者发生异常时，会自动释放锁 
25.  * @see      2)被synchronized保护的数据应该是private的，否则也就没必要去通过方法来访问这个public的数据了 
26.  * @see =================================================================================================== 
27.  * @author 宏宇 
28.  * @create Feb 21, 2012 5:29:39 PM 
29.  */  
30. public class SynchronizedTest {  
31.     public static void main(String[] args) {  
32.         Bank bank = new Bank();  
33.           
34.         Thread tt11 = new Thread(new ThreadRMB(bank));  
35.           
36.         //new一个新的Bank对象。此时存在两个Bank对象，并且它们属于同一个类的不同的对象   
37.         //如要验证多个线程操作同一个类的不同的对象的synchronized方法，只需取消注释该行代码即可   
38.         //bank = new Bank();   
39.           
40.         Thread tt22 = new Thread(new ThreadDollar(bank));  
41.           
42.         tt11.start();  
43.         tt22.start();  
44.     }  
45. }  
46.   
47.   
48. class ThreadRMB implements Runnable{  
49.     private Bank bank;  
50.     public ThreadRMB(Bank bank){  
51.         this.bank = bank;  
52.     }  
53.     @Override  
54.     public void run() {  
55.         bank.getRMB();  
56.     }  
57. }  
58.   
59.   
60. class ThreadDollar implements Runnable{  
61.     private Bank bank;  
62.     public ThreadDollar(Bank bank){  
63.         this.bank = bank;  
64.     }  
65.     @Override  
66.     public void run() {  
67.         bank.getDollar();  
68.     }  
69. }  
70.   
71.   
72. class Bank{  
73.     public synchronized void getRMB(){  
74.         for(int i=0; i<20; i++){  
75.             try {  
76.                 Thread.sleep((long)(Math.random()*1000));  
77.             } catch (InterruptedException e) {  
78.                 e.printStackTrace();  
79.             }  
80.             System.out.println(Thread.currentThread().getName() + ":" + i);  
81.         }  
82.     }  
83.       
84.     public synchronized void getDollar(){  
85.         for(int i=0; i<20; i++){  
86.             try {  
87.                 Thread.sleep((long)(Math.random()*1000));  
88.             } catch (InterruptedException e) {  
89.                 e.printStackTrace();  
90.             }  
91.             System.out.println(Thread.currentThread().getName() + ":" + i);  
92.         }  
93.     }  
94. }  

下面演示的是synchronized static Method的使用

1. package com.jadyer.thread.sync;  
2.   
3. /** 
4.  * Synchronized Static Method Test 
5.  * @see 说明：如果某个synchronized方法是static的 
6.  * @see      那么当线程访问该方法时，它锁的并不是synchronized方法所在的对象，而是该方法所在的对象所对应的Class对象 
7.  * @see      因为Java中无论一个类有多少个对象，这些对象都会对应唯一的一个Class对象 
8.  * @see      因此当线程分别访问同一个类的两个对象的两个static的synchronized方法时，它们的执行顺序也是顺序执行的 
9.  * @see      即一个线程先执行一个static的synchronized方法，执行完毕后，另一个线程才开始执行另一个static的synchronized方法 
10.  * @see 总结：重点在于判断synchronized锁的是谁。www.linuxidc.com如果该方法是静态的，则锁Class对象，否则锁的就是当前对象 
11.  * @author 宏宇 
12.  * @create Feb 21, 2012 5:29:39 PM 
13.  */  
14. public class SynchronizedStaticTest {  
15.     public static void main(String[] args) {  
16.         Bank bank = new Bank();  
17.           
18.         Thread tt11 = new Thread(new ThreadRMB(bank));  
19.         Thread tt22 = new Thread(new ThreadDollar(bank));  
20.           
21.         tt11.start();  
22.         tt22.start();  
23.     }  
24. }  
25.   
26.   
27. class ThreadRMB implements Runnable{  
28.     private Bank bank;  
29.     public ThreadRMB(Bank bank){  
30.         this.bank = bank;  
31.     }  
32.     @Override  
33.     public void run() {  
34.         bank.getRMB();  
35.     }  
36. }  
37.   
38.   
39. class ThreadDollar implements Runnable{  
40.     private Bank bank;  
41.     public ThreadDollar(Bank bank){  
42.         this.bank = bank;  
43.     }  
44.     @Override  
45.     public void run() {  
46.         bank.getDollar();  
47.     }  
48. }  
49.   
50.   
51. class Bank{  
52.     //如要验证synchronized锁同一个类的对象，和锁它的Class对象的区别   
53.     //可去掉static关键字，再查看控制台打印，即public synchronized void getRMB()   
54.     public synchronized static void getRMB(){  
55.         for(int i=0; i<20; i++){  
56.             try {  
57.                 Thread.sleep((long)(Math.random()*1000));  
58.             } catch (InterruptedException e) {  
59.                 e.printStackTrace();  
60.             }  
61.             System.out.println(Thread.currentThread().getName() + ":" + i);  
62.         }  
63.     }  
64.       
65.     public synchronized static void getDollar(){  
66.         for(int i=0; i<20; i++){  
67.             try {  
68.                 Thread.sleep((long)(Math.random()*1000));  
69.             } catch (InterruptedException e) {  
70.                 e.printStackTrace();  
71.             }  
72.             System.out.println(Thread.currentThread().getName() + ":" + i);  
73.         }  
74.     }  
75. }  

最后演示的是synchronized Block的使用

1. package com.jadyer.thread.sync;  
2.   
3. /** 
4.  * Synchronized Block Test 
5.  * @author 宏宇 
6.  * @create Feb 21, 2012 5:29:39 PM 
7.  */  
8. public class SynchronizedBlockTest {  
9.     public static void main(String[] args) {  
10.         Bank bank = new Bank();  
11.           
12.         Thread tt11 = new Thread(new ThreadRMB(bank));  
13.           
14.         //如果要验证synchronized(this)锁的是当前类的对象，而非当前类的Class对象   
15.         //则可取消注释该行代码，再观察控制台打印效果。效果应该是两个线程并发执行的输出   
16.         //bank = new Bank();   
17.           
18.         Thread tt22 = new Thread(new ThreadDollar(bank));  
19.           
20.         tt11.start();  
21.         tt22.start();  
22.     }  
23. }  
24.   
25.   
26. class ThreadRMB implements Runnable{  
27.     private Bank bank;  
28.     public ThreadRMB(Bank bank){  
29.         this.bank = bank;  
30.     }  
31.     @Override  
32.     public void run() {  
33.         bank.getRMB();  
34.     }  
35. }  
36.   
37.   
38. class ThreadDollar implements Runnable{  
39.     private Bank bank;  
40.     public ThreadDollar(Bank bank){  
41.         this.bank = bank;  
42.     }  
43.     @Override  
44.     public void run() {  
45.         bank.getDollar();  
46.     }  
47. }  
48.   
49.   
50. /** 
51.  * Bank 
52.  * @see 说明：synchronized块的写法：synchronized(object){//TODO...}，它表示线程在执行的时候，会对object对象上锁 
53.  * @see      通常会把java.lang.Object对象传进来，事实上这里可以传进来任何的对象 
54.  * @see      因为它是一个没有实际作用的对象，其仅仅起到锁的作用，就像一个标识一样 
55.  * @see 作用：它表示，如果线程能够进入到这里，即执行到这里，那么，就将object对象锁上 
56.  * @see      如果另一个线程也执行到这里，发现object对象已上锁，则会等待其解锁后，才会去执行synchronized块里面的代码 
57.  * @see 补充：synchronized(this)表示对当前类的对象上锁。注意，它锁的不是当前类的Class对象 
58.  * @see      synchronized(Bank.class)表示对当前类的Class对象上锁 
59.  * @author 宏宇 
60.  * @create Feb 22, 2012 2:29:16 AM 
61.  */  
62. class Bank{  
63.     private Object obj11 = new Object();  
64.     private Object obj22 = new Object();  
65.       
66.     public void getRMB(){  
67.         //synchronized(obj11){   
68.         synchronized (Bank.class) {  
69.             for(int i=0; i<20; i++){  
70.                 try {  
71.                     Thread.sleep((long)(Math.random()*1000));  
72.                 } catch (InterruptedException e) {  
73.                     e.printStackTrace();  
74.                 }  
75.                 System.out.println(Thread.currentThread().getName() + ":" + i);  
76.             }  
77.         }  
78.     }  
79.       
80.     public void getDollar(){  
81.         //synchronized(obj11){   
82.         //synchronized(obj22){   
83.         synchronized (this) {  
84.             for(int i=0; i<20; i++){  
85.                 try {  
86.                     Thread.sleep((long)(Math.random()*1000));  
87.                 } catch (InterruptedException e) {  
88.                     e.printStackTrace();  
89.                 }  
90.                 System.out.println(Thread.currentThread().getName() + ":" + i);  
91.             }  
92.         }  
93.     }  
94. }