我們已經瞭解了Java多執行緒程式設計中常用的關鍵字synchronized，以及與之相關的物件鎖機制。這一節中，讓我們一起來認識JDK 5中新引入的併發框架中的鎖機制。

我想很多購買了《Java程式設計師面試寶典》之類圖書的朋友一定對下面這個面試題感到非常熟悉：

問：請對比synchronized與java.util.concurrent.locks.Lock的異同。
答案：主要相同點：Lock能完成synchronized所實現的所有功能
     主要不同點：Lock有比synchronized更精確的執行緒語義和更好的效能。synchronized會自動釋放鎖，而Lock一定要求程式設計師手工釋放，並且必須在finally從句中釋放。

恩，讓我們先鄙視一下應試教育。

言歸正傳，我們先來看一個多執行緒程式。它使用多個執行緒對一個Student物件進行訪問，改變其中的變數值。我們首先用傳統的synchronized 機制來實現它：

publicclass ThreadDemo implements Runnable {

    class Student {

        privateint age =0;

        publicint getAge() {
            return age;
        }

        publicvoid setAge(int age) {
            this.age = age;
        }
    }
    Student student =new Student();
    int count =0;

    publicstaticvoid main(String[] args) {
        ThreadDemo td =new ThreadDemo();
        Thread t1 =new Thread(td, "a");
        Thread t2 =new Thread(td, "b");
        Thread t3 =new Thread(td, "c");
        t1.start();
        t2.start();
        t3.start();
    }

    publicvoid run() {
        accessStudent();
    }

    publicvoid accessStudent() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName +" is running!");
        synchronized (this) {//(1)使用同一個ThreadDemo物件作為同步鎖            System.out.println(currentThreadName +" got [email protected]!");
            try {
                count++;
                Thread.sleep(5000);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                System.out.println(currentThreadName +" first Reading count:"+ count);
            }

        }
       
        System.out.println(currentThreadName +" release [email protected]!");

        synchronized (this) {//(2)使用同一個ThreadDemo物件作為同步鎖            System.out.println(currentThreadName +" got [email protected]!");
            try {
                Random random =new Random();
                int age = random.nextInt(100);
                System.out.println("thread "+ currentThreadName +" set age to:"+ age);

                this.student.setAge(age);

                System.out.println("thread "+ currentThreadName +" first  read age is:"+this.student.getAge());

                Thread.sleep(5000);
            } catch (Exception ex) {
                ex.printStackTrace();
            } finally{
                System.out.println("thread "+ currentThreadName +" second read age is:"+this.student.getAge());
            }

        }
        System.out.println(currentThreadName +" release [email protected]!");
    }
} 轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
執行結果：

a is running!
a got [email protected]!
b is running!
c is running!
a first Reading count:1
a release [email protected]!
a got [email protected]!
thread a set age to:76
thread a first  read age is:76
thread a second read age is:76
a release [email protected]!
c got [email protected]!
c first Reading count:2
c release [email protected]!
c got [email protected]!
thread c set age to:35
thread c first  read age is:35
thread c second read age is:35
c release [email protected]!
b got [email protected]!
b first Reading count:3
b release [email protected]!
b got [email protected]!
thread b set age to:91
thread b first  read age is:91
thread b second read age is:91
b release [email protected]!
成功生成（總時間：30 秒）

顯然，在這個程式中，由於兩段synchronized塊使用了同樣的物件做為物件鎖，所以JVM優先使剛剛釋放該鎖的執行緒重新獲得該鎖。這樣，每個執行緒執行的時間是10秒鐘，並且要徹底把兩個同步塊的動作執行完畢，才能釋放物件鎖。這樣，加起來一共是30秒。
轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
我想一定有人會說：如果兩段synchronized塊採用兩個不同的物件鎖，就可以提高程式的併發性，並且，這兩個物件鎖應該選擇那些被所有執行緒所共享的物件。

那麼好。我們把第二個同步塊中的物件鎖改為student（此處略去程式碼，讀者自己修改），程式執行結果為：

a is running!
a got [email protected]!
b is running!
c is running!
a first Reading count:1
a release [email protected]!
a got [email protected]!
thread a set age to:73
thread a first  read age is:73
c got [email protected]!
thread a second read age is:73
a release [email protected]!
c first Reading count:2
c release [email protected]!
c got [email protected]!
thread c set age to:15
thread c first  read age is:15
b got [email protected]!
thread c second read age is:15
c release [email protected]!
b first Reading count:3
b release [email protected]!
b got [email protected]!
thread b set age to:19
thread b first  read age is:19
thread b second read age is:19
b release [email protected]!
成功生成（總時間：21 秒）
從修改後的執行結果來看，顯然，由於同步塊的物件鎖不同了，三個執行緒的執行順序也發生了變化。在一個執行緒釋放第一個同步塊的同步鎖之後，第二個執行緒就可以進入第一個同步塊，而此時，第一個執行緒可以繼續執行第二個同步塊。這樣，整個執行過程中，有10秒鐘的時間是兩個執行緒同時工作的。另外十秒鐘分別是第一個執行緒執行第一個同步塊的動作和最後一個執行緒執行第二個同步塊的動作。相比較第一個例程，整個程式的執行時間節省了1/3。細心的讀者不難總結出優化前後的執行時間比例公式：(n+1)/2n，其中n為執行緒數。如果執行緒數趨近於正無窮，則程式執行效率的提高會接近50%。而如果一個執行緒的執行階段被分割成m個synchronized塊，並且每個同步塊使用不同的物件鎖，而同步塊的執行時間恆定，則執行時間比例公式可以寫作：((m-1)n+1)/mn那麼當m趨於無窮大時，執行緒數n趨近於無窮大，則程式執行效率的提升幾乎可以達到100%。（顯然，我們不能按照理想情況下的數學推導來給BOSS發報告，不過通過這樣的數學推導，至少我們看到了提高多執行緒程式併發性的一種方案，而這種方案至少具備數學上的可行性理論支援。）
轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
可見，使用不同的物件鎖，在不同的同步塊中完成任務，可以使效能大大提升。

很多人看到這不禁要問：這和新的Lock框架有什麼關係？

彆著急。我們這就來看一看。

synchronized塊的確不錯，但是他有一些功能性的限制：
1.它無法中斷一個正在等候獲得鎖的執行緒，也無法通過投票得到鎖，如果不想等下去，也就沒法得到鎖。
2.synchronized塊對於鎖的獲得和釋放是在相同的堆疊幀中進行的。多數情況下，這沒問題（而且與異常處理互動得很好），但是，確實存在一些更適合使用非塊結構鎖定的情況。
轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
java.util.concurrent.lock 中的 Lock 框架是鎖定的一個抽象，它允許把鎖定的實現作為 Java類，而不是作為語言的特性來實現。這就為 Lock 的多種實現留下了空間，各種實現可能有不同的排程演算法、效能特性或者鎖定語義。

JDK官方文件中提到：
ReentrantLock是“一個可重入的互斥鎖 Lock，它具有與使用 synchronized 方法和語句所訪問的隱式監視器鎖相同的一些基本行為和語義，但功能更強大。
ReentrantLock 將由最近成功獲得鎖，並且還沒有釋放該鎖的執行緒所擁有。當鎖沒有被另一個執行緒所擁有時，呼叫 lock的執行緒將成功獲取該鎖並返回。如果當前執行緒已經擁有該鎖，此方法將立即返回。可以使用 isHeldByCurrentThread() 和getHoldCount() 方法來檢查此情況是否發生。 ”

簡單來說，ReentrantLock有一個與鎖相關的獲取計數器，如果擁有鎖的某個執行緒再次得到鎖，那麼獲取計數器就加1，然後鎖需要被釋放兩次才能獲得真正釋放。這模仿了synchronized 的語義；如果執行緒進入由執行緒已經擁有的監控器保護的 synchronized塊，就允許執行緒繼續進行，當執行緒退出第二個（或者後續） synchronized 塊的時候，不釋放鎖，只有執行緒退出它進入的監控器保護的第一個synchronized 塊時，才釋放鎖。
轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
ReentrantLock  類（重入鎖）實現了 Lock ，它擁有與 synchronized相同的併發性和記憶體語義，但是添加了類似鎖投票、定時鎖等候和可中斷鎖等候的一些特性。此外，它還提供了在激烈爭用情況下更佳的效能。（換句話說，當許多執行緒都想訪問共享資源時，JVM 可以花更少的時候來排程執行緒，把更多時間用在執行執行緒上。）

我們把上面的例程改造一下：

publicclass ThreadDemo implements Runnable {

    class Student {

        privateint age =0;

        publicint getAge() {
            return age;
        }

        publicvoid setAge(int age) {
            this.age = age;
        }
    }
    Student student =new Student();
    int count =0;
    ReentrantLock lock1 =new ReentrantLock(false);
    ReentrantLock lock2 =new ReentrantLock(false);

    publicstaticvoid main(String[] args) {
        ThreadDemo td =new ThreadDemo();
        for (int i =1; i <=3; i++) {
            Thread t =new Thread(td, i +"");
            t.start();
        }
    }

    publicvoid run() {
        accessStudent();
    }

    publicvoid accessStudent() {
        String currentThreadName = Thread.currentThread().getName();
        System.out.println(currentThreadName +" is running!");
        lock1.lock();//使用重入鎖        System.out.println(currentThreadName +" got [email protected]!");
        try {
            count++;
            Thread.sleep(5000);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            System.out.println(currentThreadName +" first Reading count:"+ count);
            lock1.unlock();
            System.out.println(currentThreadName +" release [email protected]!");
        }

        lock2.lock();//使用另外一個不同的重入鎖        System.out.println(currentThreadName +" got [email protected]!");
        try {
            Random random =new Random();
            int age = random.nextInt(100);
            System.out.println("thread "+ currentThreadName +" set age to:"+ age);

            this.student.setAge(age);

            System.out.println("thread "+ currentThreadName +" first  read age is:"+this.student.getAge());

            Thread.sleep(5000);
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            System.out.println("thread "+ currentThreadName +" second read age is:"+this.student.getAge());
            lock2.unlock();
            System.out.println(currentThreadName +" release [email protected]!");
        }

    }
}

從上面這個程式我們看到：

物件鎖的獲得和釋放是由手工編碼完成的，所以獲得鎖和釋放鎖的時機比使用同步塊具有更好的可定製性。並且通過程式的執行結果（執行結果忽略，請讀者根據例程自行觀察），我們可以發現，和使用同步塊的版本相比，結果是相同的。
轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
這說明兩點問題：
1. 新的ReentrantLock的確實現了和同步塊相同的語義功能。而物件鎖的獲得和釋放都可以由編碼人員自行掌握。
2. 使用新的ReentrantLock，免去了為同步塊放置合適的物件鎖所要進行的考量。
3.使用新的ReentrantLock，最佳的實踐就是結合try/finally塊來進行。在try塊之前使用lock方法，而在finally中使用unlock方法。
轉載註明出處：http://x-spirit.javaeye.com/、http://www.blogjava.net/zhangwei217245/
細心的讀者又發現了：

在我們的例程中，建立ReentrantLock例項的時候，我們的建構函式裡面傳遞的引數是false。那麼如果傳遞true又回是什麼結果呢？這裡面又有什麼奧祕呢？

請看本節的續 ———— Fair or Unfair? It is aquestion...

  Lock是java.util.concurrent.locks包下的介面，Lock 實現提供了比使用synchronized 方法和語句可獲得的更廣泛的鎖定操作，它能以更優雅的方式處理執行緒同步問題，我們拿Java執行緒(二)中的一個例子簡單的實現一下和sychronized一樣的效果，程式碼如下： [java] view plaincopyprint?

1. publicclass LockTest {  
2.     publicstaticvoid main(String[] args) {  
3.         final Outputter1 output = new Outputter1();  
4.         new Thread() {  
5.             publicvoid run() {  
6.                 output.output("zhangsan");  
7.             };  
8.         }.start();        
9.         new Thread() {  
10.             publicvoid run() {  
11.                 output.output("lisi");  
12.             };  
13.         }.start();  
14.     }  
15. }  
16. class Outputter1 {  
17.     private Lock lock = new ReentrantLock();// 鎖物件
18.     publicvoid output(String name) {  
19.         // TODO 執行緒輸出方法
20.         lock.lock();// 得到鎖
21.         try {  
22.             for(int i = 0; i < name.length(); i++) {  
23.                 System.out.print(name.charAt(i));  
24.             }  
25.         } finally {  
26.             lock.unlock();// 釋放鎖
27.         }  
28.     }  
29. }  

        這樣就實現了和sychronized一樣的同步效果，需要注意的是，用sychronized修飾的方法或者語句塊在程式碼執行完之後鎖自動釋放，而用Lock需要我們手動釋放鎖，所以為了保證鎖最終被釋放(發生異常情況)，要把互斥區放在try內，釋放鎖放在finally內。

        如果說這就是Lock，那麼它不能成為同步問題更完美的處理方式，下面要介紹的是讀寫鎖(ReadWriteLock)，我們會有一種需求，在對資料進行讀寫的時候，為了保證資料的一致性和完整性，需要讀和寫是互斥的，寫和寫是互斥的，但是讀和讀是不需要互斥的，這樣讀和讀不互斥效能更高些，來看一下不考慮互斥情況的程式碼原型：

[java] view plaincopyprint?

1. publicclass ReadWriteLockTest {  
2.     publicstaticvoid main(String[] args) {  
3.         final Data data = new Data();  
4.         for (int i = 0; i < 3; i++) {  
5.             new Thread(new Runnable() {  
6.                 publicvoid run() {  
7.                     for (int j = 0; j < 5; j++) {  
8.                         data.set(new Random().nextInt(30));  
9.                     }  
10.                 }  
11.             }).start();  
12.         }         
13.         for (int i = 0; i < 3; i++) {  
14.             new Thread(new Runnable() {  
15.                 publicvoid run() {  
16.                     for (int j = 0; j < 5; j++) {  
17.                         data.get();  
18.                     }  
19.                 }  
20.             }).start();  
21.         }  
22.     }  
23. }  
24. class Data {      
25.     privateint data;// 共享資料    
26.     publicvoid set(int data) {  
27.         System.out.println(Thread.currentThread().getName() + "準備寫入資料");  
28.         try {  
29.             Thread.sleep(20);  
30.         } catch (InterruptedException e) {  
31.             e.printStackTrace();  
32.         }  
33.         this.data = data;  
34.         System.out.println(Thread.currentThread().getName() + "寫入" + this.data);  
35.     }     
36.     publicvoid get() {  
37.         System.out.println(Thread.currentThread().getName() + "準備讀取資料");  
38.         try {  
39.             Thread.sleep(20);  
40.         } catch (InterruptedException e) {  
41.             e.printStackTrace();  
42.         }  
43.         System.out.println(Thread.currentThread().getName() + "讀取" + this.data);  
44.     }  
45. }  

        部分輸出結果： [java] view plaincopyprint?

1. Thread-1準備寫入資料  
2. Thread-3準備讀取資料  
3. Thread-2準備寫入資料  
4. Thread-0準備寫入資料  
5. Thread-4準備讀取資料  
6. Thread-5準備讀取資料  
7. Thread-2寫入12
8. Thread-4讀取12
9. Thread-5讀取5
10. Thread-1寫入12

        我們要實現寫入和寫入互斥，讀取和寫入互斥，讀取和讀取互斥，在set和get方法加入sychronized修飾符： [java] view plaincopyprint?

1. publicsynchronizedvoid set(int data) {...}      
2. publicsynchronizedvoid get() {...}  

        部分輸出結果：
[java] view plaincopyprint?

1. Thread-0準備寫入資料  
2. Thread-0寫入9
3. Thread-5準備讀取資料  
4. Thread-5讀取9
5. Thread-5準備讀取資料  
6. Thread-5讀取9
7. Thread-5準備讀取資料  
8. Thread-5讀取9
9. Thread-5準備讀取資料  
10. Thread-5讀取9

        我們發現，雖然寫入和寫入互斥了，讀取和寫入也互斥了，但是讀取和讀取之間也互斥了，不能併發執行，效率較低，用讀寫鎖實現程式碼如下： [java] view plaincopyprint?

1. class Data {      
2.     privateint data;// 共享資料
3.     private ReadWriteLock rwl = new ReentrantReadWriteLock();     
4.     publicvoid set(int data) {  
5.         rwl.writeLock().lock();// 取到寫鎖
6.         try {  
7.             System.out.println(Thread.currentThread().getName() + "準備寫入資料");  
8.             try {  
9.                 Thread.sleep(20);  
10.             } catch (InterruptedException e) {  
11.                 e.printStackTrace();  
12.             }  
13.             this.data = data;  
14.             System.out.println(Thread.currentThread().getName() + "寫入" + this.data);  
15.         } finally {  
16.             rwl.writeLock().unlock();// 釋放寫鎖
17.         }  
18.     }     
19.     publicvoid get() {  
20.         rwl.readLock().lock();// 取到讀鎖
21.         try {  
22.             System.out.println(Thread.currentThread().getName() + "準備讀取資料");  
23.             try {  
24.                 Thread.sleep(20);  
25.             } catch (InterruptedException e) {  
26.                 e.printStackTrace();  
27.             }  
28.             System.out.println(Thread.currentThread().getName() + "讀取" + this.data);  
29.         } finally {  
30.             rwl.readLock().unlock();// 釋放讀鎖
31.         }  
32.     }  
33. }  

        部分輸出結果：

[java] view plaincopyprint?

1. Thread-4準備讀取資料  
2. Thread-3準備讀取資料  
3. Thread-5準備讀取資料  
4. Thread-5讀取18
5. Thread-4讀取18
6. Thread-3讀取18
7. Thread-2準備寫入資料  
8. Thread-2寫入6
9. Thread-2準備寫入資料  
10. Thread-2寫入10
11. Thread-1準備寫入資料  
12. Thread-1寫入22
13. Thread-5準備讀取資料  

        從結果可以看出實現了我們的需求，這只是鎖的基本用法，鎖的機制還需要繼續深入學習。

        本文來自：高爽|Coder，原文地址：http://blog.csdn.net/ghsau/article/details/7461369，轉載請註明。