執行緒基礎(二十一)-併發容器-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