0.關於互斥鎖
所謂互斥鎖, 指的是一次最多只能有一個線程持有的鎖. 在jdk1.5之前,
我們通常使用synchronized機制控制多個線程對共享資源的訪問. 而現在, Lock提供了比synchronized機制更廣泛的鎖定操作,
Lock和synchronized機制的主要區別:
synchronized機制提供了對與每個對象相關的隱式監視器鎖的訪問, 並強制所有鎖獲取和釋放均要出現在一個塊結構中, 當獲取了多個鎖時,
它們必須以相反的順序釋放. synchronized機制對鎖的釋放是隱式的, 只要線程運行的代碼超出了synchronized語句塊範圍,
鎖就會被釋放. 而Lock機制必須顯式的調用Lock對象的unlock()方法才能釋放鎖, 這爲獲取鎖和釋放鎖不出現在同一個塊結構中,
以及以更自由的順序釋放鎖提供了可能。
1. ReentrantLock介紹
ReentrantLock是一個可重入的互斥鎖,又被稱爲“獨佔鎖”。
顧名思義,ReentrantLock鎖在同一個時間點只能被一個線程鎖持有;而可重入的意思是,ReentrantLock鎖,可以被單個線程多次獲取。
ReentrantLock分爲“公平鎖”和“非公平鎖”。它們的區別體現在獲取鎖的機制上是否公平。“鎖”是爲了保護競爭資源,防止多個線程同時操作線程而出錯,ReentrantLock在同一個時間點只能被一個線程獲取(當某線程獲取到“鎖”時,其它線程就必須等待);ReentraantLock是通過一個FIFO的等待隊列來管理獲取該鎖所有線程的。在“公平鎖”的機制下,線程依次排隊獲取鎖;而“非公平鎖”在鎖是可獲取狀態時,不管自己是不是在隊列的開頭都會獲取鎖。
ReentrantLock函數列表
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | // 創建一個 ReentrantLock ,默認是“非公平鎖”。 ReentrantLock() // 創建策略是fair的 ReentrantLock。fair爲true表示是公平鎖,fair爲false表示是非公平鎖。 ReentrantLock(boolean fair) // 查詢當前線程保持此鎖的次數。 int getHoldCount() // 返回目前擁有此鎖的線程,如果此鎖不被任何線程擁有,則返回 null。 protected Thread getOwner() // 返回一個 collection,它包含可能正等待獲取此鎖的線程。 protected Collection<Thread> getQueuedThreads() // 返回正等待獲取此鎖的線程估計數。 int getQueueLength() // 返回一個 collection,它包含可能正在等待與此鎖相關給定條件的那些線程。 protected Collection<Thread> getWaitingThreads(Condition condition) // 返回等待與此鎖相關的給定條件的線程估計數。 int getWaitQueueLength(Condition condition) // 查詢給定線程是否正在等待獲取此鎖。 boolean hasQueuedThread(Thread thread) // 查詢是否有些線程正在等待獲取此鎖。 boolean hasQueuedThreads() // 查詢是否有些線程正在等待與此鎖有關的給定條件。 boolean hasWaiters(Condition condition) // 如果是“公平鎖”返回true,否則返回false。 boolean isFair() // 查詢當前線程是否保持此鎖。 boolean isHeldByCurrentThread() // 查詢此鎖是否由任意線程保持。 boolean isLocked() // 獲取鎖。 void lock() // 如果當前線程未被中斷,則獲取鎖。 void lockInterruptibly() // 返回用來與此 Lock 實例一起使用的 Condition 實例。 Condition newCondition() // 僅在調用時鎖未被另一個線程保持的情況下,才獲取該鎖。 boolean tryLock() // 如果鎖在給定等待時間內沒有被另一個線程保持,且當前線程未被中斷,則獲取該鎖。 boolean tryLock(long timeout, TimeUnit unit) // 試圖釋放此鎖。 void unlock() |
2. ReentrantLock示例
通過對比“示例1”和“示例2”,我們能夠清晰的認識lock和unlock的作用
2.1 示例1
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 | import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; // LockTest1.java // 倉庫 class Depot { private int size; // 倉庫的實際數量 private Lock lock; // 獨佔鎖 public Depot() { this .size = 0 ; this .lock = new ReentrantLock(); } public void produce( int val) { lock.lock(); try { size += val; System.out.printf( "%s produce(%d) --> size=%d\n" , Thread.currentThread().getName(), val, size); } finally { lock.unlock(); } } public void consume( int val) { lock.lock(); try { size -= val; System.out.printf( "%s consume(%d) <-- size=%d\n" , Thread.currentThread().getName(), val, size); } finally { lock.unlock(); } } }; // 生產者 class Producer { private Depot depot; public Producer(Depot depot) { this .depot = depot; } // 消費產品:新建一個線程向倉庫中生產產品。 public void produce( final int val) { new Thread() { public void run() { depot.produce(val); } }.start(); } } // 消費者 class Customer { private Depot depot; public Customer(Depot depot) { this .depot = depot; } // 消費產品:新建一個線程從倉庫中消費產品。 public void consume( final int val) { new Thread() { public void run() { depot.consume(val); } }.start(); } } public class LockTest1 { public static void main(String[] args) { Depot mDepot = new Depot(); Producer mPro = new Producer(mDepot); Customer mCus = new Customer(mDepot); mPro.produce( 60 ); mPro.produce( 120 ); mCus.consume( 90 ); mCus.consume( 150 ); mPro.produce( 110 ); } } |
運行結果:
1 2 3 4 5 | Thread-0 produce(60) --> size=60 Thread-1 produce(120) --> size=180 Thread-3 consume(150) <-- size=30 Thread-2 consume(90) <-- size=-60 Thread-4 produce(110) --> size=50 |
結果分析:
(1) Depot 是個倉庫。通過produce()能往倉庫中生產貨物,通過consume()能消費倉庫中的貨物。通過獨佔鎖lock實現對倉庫的互斥訪問:在操作(生產/消費)倉庫中貨品前,會先通過lock()鎖住倉庫,操作完之後再通過unlock()解鎖。
(2) Producer是生產者類。調用Producer中的produce()函數可以新建一個線程往倉庫中生產產品。
(3) Customer是消費者類。調用Customer中的consume()函數可以新建一個線程消費倉庫中的產品。
(4) 在主線程main中,我們會新建1個生產者mPro,同時新建1個消費者mCus。它們分別向倉庫中生產/消費產品。
根據main中的生產/消費數量,倉庫最終剩餘的產品應該是50。運行結果是符合我們預期的!
這個模型存在兩個問題:
(1) 現實中,倉庫的容量不可能爲負數。但是,此模型中的倉庫容量可以爲負數,這與現實相矛盾!
(2) 現實中,倉庫的容量是有限制的。但是,此模型中的容量確實沒有限制的!
這兩個問題,我們稍微會講到如何解決。現在,先看個簡單的示例2;通過對比“示例1”和“示例2”,我們能更清晰的認識lock(),unlock()的用途。
2.2 示例2
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 | import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; // LockTest2.java // 倉庫 class Depot { private int size; // 倉庫的實際數量 private Lock lock; // 獨佔鎖 public Depot() { this .size = 0 ; this .lock = new ReentrantLock(); } public void produce( int val) { // lock.lock(); // try { size += val; System.out.printf( "%s produce(%d) --> size=%d\n" , Thread.currentThread().getName(), val, size); // } catch (InterruptedException e) { // } finally { // lock.unlock(); // } } public void consume( int val) { // lock.lock(); // try { size -= val; System.out.printf( "%s consume(%d) <-- size=%d\n" , Thread.currentThread().getName(), val, size); // } finally { // lock.unlock(); // } } }; // 生產者 class Producer { private Depot depot; public Producer(Depot depot) { this .depot = depot; } // 消費產品:新建一個線程向倉庫中生產產品。 public void produce( final int val) { new Thread() { public void run() { depot.produce(val); } }.start(); } } // 消費者 class Customer { private Depot depot; public Customer(Depot depot) { this .depot = depot; } // 消費產品:新建一個線程從倉庫中消費產品。 public void consume( final int val) { new Thread() { public void run() { depot.consume(val); } }.start(); } } public class LockTest2 { public static void main(String[] args) { Depot mDepot = new Depot(); Producer mPro = new Producer(mDepot); Customer mCus = new Customer(mDepot); mPro.produce( 60 ); mPro.produce( 120 ); mCus.consume( 90 ); mCus.consume( 150 ); mPro.produce( 110 ); } } |
(某一次)運行結果:
1 2 3 4 5 | Thread-0 produce(60) --> size=-60 Thread-4 produce(110) --> size=50 Thread-2 consume(90) <-- size=-60 Thread-1 produce(120) --> size=-60 Thread-3 consume(150) <-- size=-60 |
結果說明:
“示例2”在“示例1”的基礎上去掉了lock鎖。在“示例2”中,倉庫中最終剩餘的產品是-60,而不是我們期望的50。原因是我們沒有實現對倉庫的互斥訪問。
2.3 示例3
在“示例3”中,我們通過Condition去解決“示例1”中的兩個問題:“倉庫的容量不可能爲負數”以及“倉庫的容量是有限制的”。
解決該問題是通過Condition。Condition是需要和Lock聯合使用的:通過Condition中的await()方法,能讓線程阻塞[類似於wait()];通過Condition的signal()方法,能讓喚醒線程[類似於notify()]。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; import java.util.concurrent.locks.Condition; // LockTest3.java // 倉庫 class Depot { private int capacity; // 倉庫的容量 private int size; // 倉庫的實際數量 private Lock lock; // 獨佔鎖 private Condition fullCondtion; // 生產條件 private Condition emptyCondtion; // 消費條件 public Depot( int capacity) { this .capacity = capacity; this .size = 0 ; this .lock = new ReentrantLock(); this .fullCondtion = lock.newCondition(); this .emptyCondtion = lock.newCondition(); } public void produce( int val) { lock.lock(); try { // left 表示“想要生產的數量”(有可能生產量太多,需多此生產) int left = val; while (left > 0 ) { // 庫存已滿時,等待“消費者”消費產品。 while (size >= capacity) fullCondtion.await(); // 獲取“實際生產的數量”(即庫存中新增的數量) // 如果“庫存”+“想要生產的數量”>“總的容量”,則“實際增量”=“總的容量”-“當前容量”。(此時填滿倉庫) // 否則“實際增量”=“想要生產的數量” int inc = (size+left)>capacity ? (capacity-size) : left; size += inc; left -= inc; System.out.printf( "%s produce(%3d) --> left=%3d, inc=%3d, size=%3d\n" , Thread.currentThread().getName(), val, left, inc, size); // 通知“消費者”可以消費了。 emptyCondtion.signal(); } } catch (InterruptedException e) { } finally { lock.unlock(); } } public void consume( int val) { lock.lock(); try { // left 表示“客戶要消費數量”(有可能消費量太大,庫存不夠,需多此消費) int left = val; while (left > 0 ) { // 庫存爲0時,等待“生產者”生產產品。 while (size <= 0 ) emptyCondtion.await(); // 獲取“實際消費的數量”(即庫存中實際減少的數量) // 如果“庫存”<“客戶要消費的數量”,則“實際消費量”=“庫存”; // 否則,“實際消費量”=“客戶要消費的數量”。 int dec = (size<left) ? size : left; size -= dec; left -= dec; System.out.printf( "%s consume(%3d) <-- left=%3d, dec=%3d, size=%3d\n" , Thread.currentThread().getName(), val, left, dec, size); fullCondtion.signal(); } } catch (InterruptedException e) { } finally { lock.unlock(); } } public String toString() { return "capacity:" +capacity+ ", actual size:" +size; } }; // 生產者 class Producer { private Depot depot; public Producer(Depot depot) { this .depot = depot; } // 消費產品:新建一個線程向倉庫中生產產品。 public void produce( final int val) { new Thread() { public void run() { depot.produce(val); } }.start(); } } // 消費者 class Customer { private Depot depot; public Customer(Depot depot) { this .depot = depot; } // 消費產品:新建一個線程從倉庫中消費產品。 public void consume( final int val) { new Thread() { public void run() { depot.consume(val); } }.start(); } } public class LockTest3 { public static void main(String[] args) { Depot mDepot = new Depot( 100 ); Producer mPro = new Producer(mDepot); Customer mCus = new Customer(mDepot); mPro.produce( 60 ); mPro.produce( 120 ); mCus.consume( 90 ); mCus.consume( 150 ); mPro.produce( 110 ); } } |
(某一次)運行結果:
1 2 3 4 5 6 7 8 9 10 | Thread-0 produce( 60) --> left= 0, inc= 60, size= 60 Thread-1 produce(120) --> left= 80, inc= 40, size=100 Thread-2 consume( 90) <-- left= 0, dec= 90, size= 10 Thread-3 consume(150) <-- left=140, dec= 10, size= 0 Thread-4 produce(110) --> left= 10, inc=100, size=100 Thread-3 consume(150) <-- left= 40, dec=100, size= 0 Thread-4 produce(110) --> left= 0, inc= 10, size= 10 Thread-3 consume(150) <-- left= 30, dec= 10, size= 0 Thread-1 produce(120) --> left= 0, inc= 80, size= 80 Thread-3 consume(150) <-- left= 0, dec= 30, size= 50 |