Java並發編程之——Lock(重入鎖，讀寫鎖)及Condition示例

　　在JDK5的並發包中有一個子包為java.concurrent.locks，它下面定義了三個接口Lock,ReadWriteLock,Condition,分別為重入鎖，讀寫鎖，鎖條件判斷

LOCK:

Lock與java關鍵字（synchronized）具有相同的功能，但它更加靈活。ReentrantLock作為Lock接口的實現類，被作為Java語言中synchronized功能的替代，它們具有相同的內存意義，相同的鎖定，但在爭用條件下卻有更好的性能，此為它還有synchronized沒有提供的其它特性。但就實際應用來說，由於內部鎖是內置於Java虛擬機中的，它能夠進行優化，因此未來的性能改進可能更傾向於內部鎖，而不是重入鎖。綜上所述，除非你的應用程序需要發在Java 5.0上，或者需要使用重入鎖的可伸縮性，否則就應該選擇內部鎖。

總之，ReentrantLock鎖與Java內在鎖相比有下面的特點：

1）ReentrantLock必須在 finally 塊中釋放鎖，而使用synchronized同步，JVM 將確保鎖會獲得自動釋放。

2）與目前的 synchronized 實現相比，爭用下的 ReentrantLock 實現更具可伸縮性。

3）對於ReentrantLock ，可以有不止一個條件變量與它關聯。（Condition后面會說到）

4）允許選擇想要一個公平鎖，還是一個不公平鎖。(new ReentrantLock(false)非公平鎖，非公平鎖執行效率會更高)

5）除非你對 Lock 的某個高級特性有明確的需要，或者有明確的證據表明在特定情況下，同步已經成為可伸縮性的瓶頸，否則還是應當繼續使用synchronized。

6）Lock 類只是普通的類，JVM 不知道具體哪個線程擁有 Lock 對象。而且，幾乎每個開發人員都熟悉 synchronized，它可以在 JVM 的所有版本中工作。

Condition:

類似於java中原來線程交互所用的wait,notify和notifyAll方法在新的並發包中基於重入鎖機制引入了Condition接口，Condition 將 Object 監視器方法（wait、notify 和 notifyAll）分解成截然不同的對象，以便通過將這些對象與任意 Lock 實現組合使用，為每個對象提供多個等待 set（wait-set），就是多路等待。Condition 的方法與 wait 、notify 和 notifyAll 方法類似，分別命名為 await 、 signal和singalAll因為它們不能覆蓋Object上的對應方法。

下面是一個多路條件等待按順序執行的例子，給定一個0,按1，2，3，這樣的順序依次加一次，總共加10次，並輸出每次加后的結果，模擬讓多線程來做：

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConditionTest {

    /**
     * @param args
     */
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(new Runnable() {

                @Override
                public void run() {
                    new Test1().sub1();

                }
            }).start();

            new Thread(new Runnable() {

                @Override
                public void run() {
                    new Test1().sub2();

                }
            }).start();

            new Thread(new Runnable() {

                @Override
                public void run() {
                    new Test1().sub3();

                }
            }).start();
        }
    }

}

class Test1 {
    public static int i = 0;
    public static int conNum = 1;
    //此處注意鎖和condition也要定義成靜態的，不然就有多把鎖和condition了,相當於沒加一樣。
    public static Lock lock = new ReentrantLock(false);
    public static Condition con1 = lock.newCondition();
    public static Condition con2 = lock.newCondition();
    public static Condition con3 = lock.newCondition();

    // 方法1對i進行加1
    public  void sub1() {
        lock.lock();
        try {
            while (conNum != 1) {
                try {
                    con1.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i++;
            System.out.print(i + ",");
            conNum = 2;
            con2.signal();
        } finally {
            lock.unlock();
        }

    }

    // 方法2對i加2
    public void sub2() {
        lock.lock();

        try {
            while (conNum != 2) {
                try {
                    con2.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i = i + 2;
            System.out.print(i + ",");
            conNum = 3;
            con3.signal();
        } finally {
            lock.unlock();
        }

    }

    // 方法3對i加3;
    public void sub3() {
        lock.lock();
        try {
            while (conNum != 3) {
                try {
                    con3.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            i = i + 3;
            System.out.print(i + ",");
            conNum = 1;
            con1.signal();
        } finally {
            lock.unlock();
        }

    }

}

 

ReadWriteLock:

ReadWriteLock 維護了一對相關的鎖，一個用於只讀操作，另一個用於寫入操作。只要沒有 writer，讀取鎖可以由多個 reader 線程同時保持。寫入鎖是獨占的。從理論上說，使用讀寫鎖所允許的並發性增強將帶來更大的性能提高。與互斥鎖相比，使用讀-寫鎖能否提升性能則取決於讀寫操作期間讀取數據相對於修改數據的頻率，以及數據的爭用——即在同一時間試圖對該數據執行讀取或寫入操作的線程數。

下面一個示例，模擬各有10個線程對數據源數據進行讀寫，從輸出結果可以看出實現了有序的讀寫

public class LockTest {
    /**
     * @param args
     */
    public static void main(String[] args){
        //10個讀線程
      for(int i=0;i<10;i++){
          new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"讀取到的數據為："+new Data().get());
            }
        }).start();
      }
      //10個寫線程
      for(int i=0;i<10;i++){
          final int num = i;
          new Thread(new Runnable() {
            @Override
            public void run() {
                new Data().set("world"+num);
            }
        }).start();
      }
    }
    
    
    
}
//數據源 
class Data{
    private static String name="hello";
    ReadWriteLock rwl = new ReentrantReadWriteLock();
    public String get(){
        rwl.readLock().lock();
        System.out.println(Thread.currentThread().getName()+"--讀取數據前：");
        
        try{try {
            Thread.sleep(new Random().nextInt(3000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return name;
        }finally{
            System.out.println(Thread.currentThread().getName()+"--已經讀取完");
            rwl.readLock().unlock();
        }
        
        }
    
    public void set(String name){
        rwl.writeLock().lock();
        try{
        System.out.println(Thread.currentThread().getName()+">寫入數據前");
        try {
            Thread.sleep(new Random().nextInt(3000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.name = name;
        System.out.println(Thread.currentThread().getName()+">寫完數據");
        }finally{
            rwl.writeLock().unlock();
        }
        
    }
}