java併發編程學習之顯示鎖Lock

顯示鎖和內置鎖

內置鎖（Synchronized）優點

1. 代碼簡潔
2. 不會由於沒釋放鎖，致使鎖泄露。

顯示鎖（Lock）優點

1. 靈活性強，鎖的獲取能夠被中斷，能夠嘗試獲取鎖。
2. 讀多寫少等場景。

用法

能用內置鎖就用內置鎖，不能用內置鎖，才考慮用顯示鎖。

Lock接口

接口主要方法以下：

1. lock()：獲取鎖
2. tryLock()：嘗試獲取鎖，true表示未加鎖的狀況。
3. unlock()：釋放鎖
4. newCondition()：建立一個Condition

Condition接口

接口主要方法以下：

1. await()：等待，相似wait方法
2. signal()：喚醒，相似notify方法
3. signalAll()：喚醒所有，相似notifAll方法

使用形式

Lock lock = new ReentrantLock();
....
lock.lock();//獲取鎖
try{
    //業務邏輯
}finally{
    lock.unlock();//這邊要注意釋放，否則會致使鎖泄露
}

示例

public class LockDemo {
    Lock lock = new ReentrantLock();
    static int num = 0;

    public void addNum(int value) {
        lock.lock();
        try {
            int temp = num;
            num = num + value;
            Thread.sleep(100);
            System.out.println(value + "+" + temp + "=" + num);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    static class AddThread1 extends Thread {
        LockDemo lockDemo;

        public AddThread1(LockDemo lockDemo) {
            this.lockDemo = lockDemo;
        }

        @Override
        public void run() {
            lockDemo.addNum(1);
        }
    }

    static class AddThread2 extends Thread {
        LockDemo lockDemo;

        public AddThread2(LockDemo lockDemo) {
            this.lockDemo = lockDemo;
        }

        @Override
        public void run() {
            lockDemo.addNum(2);
        }
    }


    public static void main(String[] args) {
        LockDemo lockDemo = new LockDemo();
        AddThread1 addThread1 = new AddThread1(lockDemo);
        AddThread2 addThread2 = new AddThread2(lockDemo);
        addThread1.start();
        addThread2.start();
    }
}

運行結果以下：

結果顯示，跟以前synchronized結果是同樣的，加鎖解鎖成功

公平鎖和非公平鎖

1. 公平鎖：先進來的線程先執行
2. 非公平鎖：後進來的線程可能先執行，效率較高。會進行搶鎖操做，若是cas獲取不到鎖，也會進入阻塞隊列等到喚醒。

ReentrantLock

構造參數有兩個，默認是非公平鎖，若是傳參是true，則是公平鎖。

public ReentrantLock() {
    sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}