1. 程式人生 > >執行緒基礎(二十一)-併發容器-ArrayBlockingQueue(上)

執行緒基礎(二十一)-併發容器-ArrayBlockingQueue(上)

本文作者:王一飛,叩丁狼高階講師。原創文章,轉載請註明出處。

在正式講解ArrayBlockingQueue類前,先來科普一下執行緒中各類鎖,只有瞭解這些鎖之後,理解ArrayBlockingQueue那就更輕鬆了。

可重入鎖

一種遞迴無阻塞的同步機制,也叫做遞迴鎖。簡單講一個執行緒獲取到鎖物件之後,還是可以再次獲取該鎖物件時,不會發生阻塞。

java中 synchronized 跟ReentrantLock 都是可重入鎖, synchronized 為隱性, 而ReentrantLock 為顯示。 下面以synchronized 為例:

public class ThreadDemo {
    public synchronized void method1(){
        System.out.println(Thread.currentThread().getName() + "進入method1....");
        try {
            Thread.sleep(1000);
            method2();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public synchronized void method2(){
        System.out.println(Thread.currentThread().getName() + "進入method2....");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
public class App {
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadDemo.method1();
            }
        }, "t1").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadDemo.method2();
            }
        }, "t2").start();
        new Thread(new Runnable() {
            @Override
            public void run() {
                threadDemo.method2();
            }
        }, "t3").start();
    }
}

執行結果

上面程式碼, t1執行緒先進入method1, 1s之後進入method2, 因為使用synchronized 加鎖,t2, t3執行緒無法進入method2,必須等,而t1執行緒執行完method1後,可以直接進入method2, 無需要重複獲取鎖的操作。
改進: 可以再多開幾個執行緒訪問method2方法,會發現結果是一致的。

不可重入鎖

不可重入鎖是跟重入鎖是對立的,表示一執行緒獲取到鎖物件後,想再次獲取該鎖物件時,必須先釋放之前獲取鎖物件,否則阻塞等待。
java中沒有執行緒類實現不可重入鎖,更多時候,需要我們程式設計實現。

//自定義鎖物件模擬不可重入鎖
public class MyLock {
    private boolean isLock = false;
    //模擬獲取鎖
    public synchronized void lock() throws InterruptedException {
        //自旋排除一些硬體執行干擾
        while(isLock){
            wait();
        }
        isLock = true;
    }
    //模擬釋放鎖
    public synchronized  void unLock(){
        isLock = false;
        notify();
    }
}
public class ThreadDemo {
    private MyLock lock = new MyLock();

    public void method1() throws InterruptedException {
        lock.lock();
        System.out.println("method1...in");
        method2();
        System.out.println("method1...out");
        lock.unLock();
    }

    public void method2() throws InterruptedException {
        lock.lock();
        System.out.println("method2......");
        lock.unLock();
    }
}
public class App {
    public static void main(String[] args) throws InterruptedException {
        ThreadDemo demo = new ThreadDemo();
        demo.method1();
    }
}

執行之後, 列印只有method1...in, 在執行method1時,呼叫lock.lock()方法, isLock標記量改為true,表示鎖被持有,跳過迴圈。 執行method2時,再次執行lock.lock(),isLock標籤為true, 進入迴圈,執行緒等待。模擬拉當鎖已經被持有,同一個執行緒第二次申請同一把鎖,需要等待。

互斥鎖

同一個時刻,只允許獲取到所物件的執行緒執行。synchronized ReentrantLock 本身就是互斥鎖。

public class ThreadDemo {
    //同一個時刻只允許一個執行緒進入
    public synchronized void method1(){
        System.out.println(Thread.currentThread().getName() + "進入....");
    }
}
public class ThreadDemo {
    private ReentrantLock lock = new ReentrantLock();
    //同一個時刻只允許一個執行緒進入
    public  void method1(){
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "進入...."); 
        }finally {
            lock.unlock();
        }
    }
}

自旋鎖

一種非阻塞鎖,也就是說,如果某執行緒需要獲取鎖,但鎖已經被執行緒佔用時,執行緒不阻塞等待,而是通過空迴圈來消耗CPU時間片,等待其他執行緒釋放鎖。注意,自旋鎖中的迴圈也不是瞎迴圈, 一般會設定一定迴圈次數或者迴圈跳出條件。
自旋鎖運用非常廣泛, jdk中的juc包原子操作類中都是, 比如: AtomicInteger

public class AtomicInteger extends Number implements java.io.Serializable {
   public final int getAndSet(int newValue) {
        return unsafe.getAndSetInt(this, valueOffset, newValue);
    }
}

Unsafe類

public final int getAndSetInt(Object var1, long var2, int var4) {
        int var5;
        do {
            var5 = this.getIntVolatile(var1, var2);
        } while(!this.compareAndSwapInt(var1, var2, var5, var4));

        return var5;
 }

偏向鎖 / 輕量級鎖 / 重量級鎖

偏向鎖,輕量鎖,重量鎖並不是對執行緒加鎖機制,而是jdk1.6之後提出的對執行緒加鎖的優化策略。
偏向鎖:當執行緒沒有競爭的環境下,需要重複獲取某個鎖物件時,jvm為減少開銷,讓執行緒進入偏向模式,再次獲取鎖物件時,取消之前已經獲取鎖同步操作(即一系列的cas判斷),直接取得鎖物件。如果期間有其他執行緒參與競爭,則退出偏向模式。

當執行緒退出偏向模式最後,進入輕量級鎖模式。此時,執行緒嘗試使用自旋方式來獲取鎖,如果獲取成功,繼續邏輯執行, 如果獲取失敗,表示當前鎖物件存在競爭,鎖就會膨脹成重量級鎖。

當執行緒進入重量級鎖模式, 所有操作就跟我們所認知那樣,爭奪CUP,在操作過程中,爭奪失敗執行緒會被作業系統掛起,阻塞等待。那麼執行緒間的切換和呼叫成本就會大大提高,效能也就對應下降了。

樂觀鎖

顧名思義,就是很樂觀,在獲取資料時認為別人不會對資料做修改,所以不上鎖,但是在更新的時候會先判斷別人有沒有更新了此資料,最通用的實現是使用版本號判斷方式,java的juc併發包中的原子操作類使用的CAS機制,其實也是一種樂觀鎖實現。

悲觀鎖

與樂觀鎖是相對的,操作前都假設最壞的情況,在獲取資料的認為別人會對資料做修改,所以每次操作前都會上鎖。而別人想操作此資料就會阻塞直到它拿到鎖。Java中synchronized關鍵字ReentrantLock的實現便是悲觀鎖。

公平鎖

公平鎖,講究公平,當鎖物件被佔用時,參與鎖物件爭奪的執行緒按照FIFO的順序排序等待鎖釋放,人人有機會,不爭不搶。

public class Resource implements Runnable {

    private ReentrantLock lock = new ReentrantLock(true);  //公平鎖
    public void run() {
        System.out.println(Thread.currentThread().getName() + " 進入了.....");
        lock.lock(); //爭鎖
        try {
            System.out.println(Thread.currentThread().getName() + " 獲取鎖並執行了.....");
        }finally {
            lock.unlock();
        }
    }
}
public class App {
    public static void main(String[] args) throws InterruptedException {

        Resource resource = new Resource(); //共享資源
        for (int i = 0; i <10; i++) {
            new Thread(resource, "t_" + i).start();
        }
    }
}
t_4 進入了.....
t_2 進入了.....
t_4 獲取鎖並執行了.....
t_7 進入了.....
t_6 進入了.....
t_3 進入了.....
t_5 進入了.....
t_2 獲取鎖並執行了.....
t_7 獲取鎖並執行了.....
t_6 獲取鎖並執行了.....
t_3 獲取鎖並執行了.....
t_5 獲取鎖並執行了.....
t_0 進入了.....
t_0 獲取鎖並執行了.....
t_1 進入了.....
t_1 獲取鎖並執行了.....
t_8 進入了.....
t_8 獲取鎖並執行了.....
t_9 進入了.....
t_9 獲取鎖並執行了.....

觀察執行結果,當鎖是公平鎖時(new ReentrantLock(true))會發現進入順序是4,2,7,6,3,5,0,1,8,9 而執行的順序是4,2,7,6,3,5,0,1,8,9。兩者順序一樣,這就是公平的體現,誰先來,誰先執行。

非公平鎖

與公平鎖相對,當鎖物件被釋放時,所有參與爭奪鎖物件的執行緒各憑本事,撐死膽大的,餓死膽小的。

其他程式碼不變,僅僅將引數改為false或者去掉
private ReentrantLock lock = new ReentrantLock(false);  //非公平鎖
t_4 進入了.....
t_2 進入了.....
t_5 進入了.....
t_3 進入了.....
t_4 獲取鎖並執行了.....
t_7 進入了.....
t_7 獲取鎖並執行了.....
t_0 進入了.....
t_1 進入了.....
t_0 獲取鎖並執行了.....
t_8 進入了.....
t_2 獲取鎖並執行了.....
t_9 進入了.....
t_9 獲取鎖並執行了.....
t_6 進入了.....
t_5 獲取鎖並執行了.....
t_3 獲取鎖並執行了.....
t_1 獲取鎖並執行了.....
t_8 獲取鎖並執行了.....
t_6 獲取鎖並執行了.....

當鎖是非公平鎖時(new ReentrantLock(false))進入的順序與執行順序不一樣啦,這就是非公平鎖,爭奪CPU各憑本事。

好的,到這執行緒中的鎖知識普及就結束了。

想獲取更多技術乾貨,請前往叩丁狼官網:http://www.wolfcode.cn/all_article.html