Java中的Lock與synchronized

並發編程學習筆記之Lock與synchronized

一、什么是可重入鎖

Lcok在Java中是一個接口，一般在面試問題中問到的可能是ReentrantLock與synchronized的區別。ReentrantLock是Lock的一個實現類，字面意思的話就是可重入鎖，那么什么是可重入鎖呢。

可重入鎖是鎖的一個相關概念，並不是特指我們的ReentrantLock，而是如果一個鎖具備可重入性，那我們就說這是一個可重入鎖。ReentrantLock和synchronized都是可重入鎖。至於什么是可重入性，這里舉個簡單的例子，現在在一個類里我們有兩個方法（代碼如下），一個叫做去北京，一個叫做買票，那我們在去北京的方法里可以直接調用買票方法，假如兩個方法全都用synchronized修飾的話，在執行去北京的方法，線程獲取了對象的鎖，接着執行買票方法，如果synchronized不具備可重入性，那么線程已經有這個對象的鎖了，現在又來申請，就會導致線程永遠等待無法獲取到鎖。而synchronized和ReentrantLock都是可重入鎖，就不會出現上述的問題。

class Trip {
    public synchronized void goToBeiJing() {
        // 去北京  
        buyATicket();
    }
     
    public synchronized void buyATicket() {
        // 買票
    }
}    

二、Lock與synchronized的不同

二者都是可重入鎖，那么為什么要有兩個呢？既然存在，那么就一定是有意義的。synchronized是Java中的一個關鍵字，而Lock是Java1.5后在java.util.concurrent.locks包下提供的一種實現同步的方法，那么顯然的，synchronized一定是有什么做不到的或者缺陷，才導致了Lock的誕生。

1.synchronized的缺點

1）當一個代碼塊被synchronized修飾的時候，一個線程獲取到了鎖，並且執行代碼塊，那么其他的線程需要等待正在使用的線程釋放掉這個鎖，那么釋放鎖的方法只有兩種，一種是代碼執行完畢自動釋放，一種是發生異常以后jvm會讓線程去釋放鎖。那么如果這個正在執行的線程遇到什么問題，比如等待IO或者調用sleep方法等等被阻塞了，無法釋放鎖，而這時候其他線程只能一直等待，將會特別影響效率。那么有沒有一種辦法讓其他線程不必一直傻乎乎的等在這里嗎？

2）當一個文件，同時被多個線程操作時，讀操作和寫操作會發生沖突，寫操作和寫操作會發生沖突，而讀操作和讀操作並不會沖突，但是如果我們用synchronized的話，會導致一個線程在讀的時候，其他線程想要讀的話只能等待，那么有什么辦法能不鎖讀操作嗎？

3）在使用synchronized時，我們無法得知線程是否成功獲取到鎖，那么有什么辦法能知道是否獲取到鎖嗎？

2.java.util.concurrent.locks包

1）Lock

Lock是一個接口，源碼如下

public interface Lock {
    void lock();
    void lockInterruptibly() throws InterruptedException;
    boolean tryLock();
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    void unlock();
    Condition newCondition();
}

ReentrantLock是Lock的一個實現類（另外兩個實現類是ReentrantReadWriteLock類下的兩個靜態內部類：WriteLock和ReadLock），它的意思是可重入鎖，可重入鎖前面已經講過了。ReentrantLock中提供了更多的一些方法。不過常用的就是Lock中的這些。

來看一下Lock接口這些方法的使用，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用來獲取鎖的。unLock()方法是用來釋放鎖的。

這里有四個方法來獲取鎖，那么區別在哪里呢？

lock()使我們平時用的最多的，最用是用來獲取鎖，如果鎖已經被其他線程獲取，那么就等待。但是采用Lock必須要主動釋放鎖，所以我們一般在try{}catch{}塊中處理然后在finally中釋放鎖，舉個例子：

lock.lock();
try{
    // 處理
}catch(Exception ex){
    // 捕獲異常
}finally{
    // 釋放鎖
    lock.unlock();   
}

 tryLock()是一個boolean類型的方法，當調用這個方法的時候，線程會去嘗試獲取鎖，如果獲取到的話會返回true，如果獲取不到返回false，也就是說這個方法會立馬返回一個結果，線程不會等待。

tryLock(long time, TimeUnit unit)是上面tryLock()方法的一個重載方法，加了兩個參數，給定了等待的時間，如果在規定時間拿到鎖返回true，如果拿不到返回false。這兩個方法的一般用法和Lock類似。

if (lock.tryLock()) {
    try{
        // 處理    
    }catch(Exception ex){
        // 捕獲異常
    }finally{
        // 釋放鎖
        lock.unlock();   
    }
}

lockInterruptibly()就比較特殊了，它表示可被中斷的，意思就是，當嘗試獲取鎖的時候，如果獲取不到的話就會等待，但是，在等待的過程中它是可以響應中斷的，也就是中斷線程的等待過程。使用形式的話一樣用try catch處理，就不貼代碼了。

2）ReadWriteLock

ReadWriteLock也是一個接口，這個接口中只有兩個方法，源碼如下：

public interface ReadWriteLock {
    Lock readLock();
 
    Lock writeLock();
}

這個接口的從字面就能看出來他的用途，讀鎖和寫鎖，這時候是不是想起了前面我寫到的synchronized的第二條。

ReentrantReadWriteLock是ReadWriteLock的一個實現類，最常用到的也是獲取讀鎖和獲取寫鎖。下面看例子：

首先是使用synchronized的：

public class Main {  
    public static void main(String[] args)  {
        final Main m = new Main();
       
        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start(); 
    }  
     
    public synchronized void read(Thread thread) {
        long startTime = System.currentTimeMillis();
        while(System.currentTimeMillis() - startTime <= 1) {
            System.out.println(thread.getName()+"線程在進行讀操作");
        }
        System.out.println(thread.getName()+"線程完成讀操作");
    }
}

這段代碼的執行結果是在一個線程打印出完成讀操作后，另一條線程才會開始進行讀操作。

Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程完成讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程完成讀操作

 

下面看如果用ReadWriteLock：

public class Main {  
    public static void main(String[] args)  {
        private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        final Main m = new Main();
       
        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                m.read(Thread.currentThread());
            };
        }.start(); 
    }  
     
    public void read(Thread thread) {
        readWriteLock.readLock().lock();
        try {
        long startTime = System.currentTimeMillis();
            while(System.currentTimeMillis() - startTime <= 1) {
                System.out.println(thread.getName()+"線程在進行讀操作");
            }
            System.out.println(thread.getName()+"線程完成讀操作");
    } finally {
        readWriteLock.unlock();
        }
    }
}

只是把之前的synchronized換成了ReadWriteLock，但是輸出結果卻是兩個線程在一起進行讀操作

Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程在進行讀操作
Thread-1線程在進行讀操作
Thread-0線程完成讀操作
Thread-1線程完成讀操作

這個結果可以看到兩個線程同時進行讀操作，效率大大的提升了。但是要注意的是，如果一個線程獲取了讀鎖，那么另外的線程想要獲取寫鎖則需要等待釋放；而如果一個線程已經獲取了寫鎖，則另外的線程想獲取讀鎖或寫鎖都需要等待寫鎖被釋放。

三、總結

總結一下二者：

1.synchronized是Java的關鍵字，是內置特性，而Lock是一個接口，可以用它來實現同步。

2.synchronized同步的時候，其中一條線程用完會自動釋放鎖，而Lock需要手動釋放，如果不手動釋放，可能會造成死鎖。

3.使用synchronized如果其中一個線程不釋放鎖，那么其他需要獲取鎖的線程會一直等待下去，知道使用完釋放或者出現異常，而Lock可以使用可以響應中斷的鎖或者使用規定等待時間的鎖

4.synchronized無法得知是否獲取到鎖，而Lcok可以做到。

5.用ReadWriteLock可以提高多個線程進行讀操作的效率。

所以綜上所述，在兩種鎖的選擇上，當線程對於資源的競爭不激烈的時候，效率差不太多，但是當大量線程同時競爭的時候，Lock的性能會遠高於synchronized。