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. }  
    76. 最后演示的是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. }