站長資訊網
免費學習推薦：java基礎教程
Lock鎖與生產者消費者問題
- 傳統Synchronized鎖
- Lock鎖
- Synchronized和lock鎖的區別
- 傳統的生產者和消費者問題
- Lock版的生產者和消費者問題
- Condition實現精準通知喚醒
傳統Synchronized鎖
實現一個基本的售票例子：
/* 真正的多線程開發，公司中的開發,降低耦合性 線程就是一個單獨的資源類，沒有任何附屬的操作 1.屬性，方法 * */public class SaleTicketDemo1 { public static void main(String[] args) { //并發，多個線程操作同一個資源類,把資源類丟入線程 Ticket ticket=new Ticket(); //Runnable借口是一個FunationalInterface函數式接口，接口可以new,jdk1.8以后，lamda表達式()->{代碼} new Thread(()->{ for(int i=0;i<60;i++){ ticket.sale(); } },"A").start(); new Thread(new Runnable() { @Override public void run() { for(int i=0;i<60;i++){ ticket.sale(); } } },"B").start(); new Thread(()->{ for(int i=0;i<60;i++){ ticket.sale(); } },"C").start(); }}//資源類 OOPclass Ticket{ //屬性，方法 private int number=50; //賣票的方式 //synchronized本質：隊列，所 public synchronized void sale(){ if(number>0){ System.out.println(Thread.currentThread().getName()+"賣出了"+(number--)+"票,剩余"+number); } }}
注意，這里面用到了lambda表達式，lambda表達式詳細描述見Java基礎-Lambda表達式
這是使用傳統的synchronized實現并發，synchronized的本質就是隊列，鎖。就好比食堂排隊。如果沒有排隊，就會很亂。只有給一個人服務完成了，另一個人才能接收到服務。
Lock鎖
之前已經說道，JVM提供了synchronized關鍵字來實現對變量的同步訪問以及用wait和notify來實現線程間通信。在jdk1.5以后，JAVA提供了Lock類來實現和synchronized一樣的功能，并且還提供了Condition來顯示線程間通信。
Lock類是Java類來提供的功能，豐富的api使得Lock類的同步功能比synchronized的同步更強大。
在java.util. Concurrent包中，里面有3個接口，Condition，lock(標準鎖)。ReadWriteLock鎖（讀寫鎖）
Lock實現提供比使用synchronized方法和語句可以獲得的更廣泛的鎖定操作。 它們允許更靈活的結構化，可能具有完全不同的屬性，并且可以支持多個相關聯的對象Condition。
Lock l = ...; l.lock(); try { // access the resource protected by this lock } finally { l.unlock(); }
lock()表示加鎖，unlock()表示解鎖
JDK官方文檔中解釋
所有已知實現類：
ReentrantLock可重入鎖
ReentrantReadWriteLock.ReadLock 讀鎖
ReentrantReadWriteLock.writeLock寫鎖
先說ReentrantLock實現類：
ReentrantLock底層源碼構造函數
公平鎖：十分公平，可以先來后到。但是問題如果一個3s和一個3h的進程到達，3h先，那么3s等3h，實際上也不利。
非公平鎖：十分不公平，可以插隊（默認）
之后，我們會具體解釋。
怎么用，用之前加鎖，用之后解鎖
//lock鎖三部曲
//1.new ReentranLock();構造
//2.Lock.lock();加鎖
//3.finally();解鎖
public class SaleTicketDemo2 { public static void main(String[] args) { //并發，多個線程操作同一個資源類,把資源類丟入線程 Ticket ticket=new Ticket(); //Runnable借口是一個FunationalInterface函數式接口，接口可以new,jdk1.8以后，lamda表達式()->{代碼} new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"A").start(); new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"B").start(); new Thread(()->{for(int i=0;i<60;i++)ticket.sale();},"C").start(); }}//資源類 OOP//lock鎖三部曲//1.new ReentranLock();//2.Lock.lock();加鎖//3.finally();解鎖class Ticket2{ //屬性，方法 private int number=50; //賣票的方式 //synchronized本質：隊列，所 Lock lock=new ReentrantLock(); public void sale(){ lock.lock(); try { //業務代碼 if(number>0){ System.out.println(Thread.currentThread().getName()+"賣出了"+(number--)+"票,剩余"+number); } } catch (Exception e) { // TODO: handle exception }finally{ lock.unlock(); } }}
Synchronized和lock鎖的區別
1.synchronized是內置的java關鍵字，lock是一個Java類
2.synchronized無法判斷獲取鎖的狀態，lock可以判斷是否獲取到了鎖
3.synchronized會自動釋放鎖(a–),lock必須要手動釋放鎖！如果不釋放鎖，會導致死鎖
4.Synchronized線程1（獲得鎖，阻塞），線程2（等待，傻傻的等）
lock.tryLock()嘗試獲取鎖，不一定會一直等待下去
5.Synchronized可重入鎖，不可以中斷的，非公平鎖。Lock,可重入鎖，可以判斷鎖，公平與非公平可以自己設置（可以自己設置）
6.synchronized適合少量的代碼同步問題，lock鎖適合鎖大量的同步代碼
synchornized鎖對象和同步代碼塊方法
傳統的生產者和消費者問題
傳統的生產者和消費者是基于Object類的wait、notify方法和synchronized關鍵字來實現的。
在面試的時候，手寫生產者消費者代碼是很常見的事情。
面試筆試經典問題：
單例模式+排序算法+生產者消費者+死鎖
生產者消費者問題synchronized版
線程之間的通信問題：生產者和消費者問題 等待喚醒，通知喚醒
線程交替執行 A B 操作同一個變量number=0
A num+1
B num-1
注意：加鎖的方法中，執行的思路是判斷等待+業務+通知
package testConcurrent;/* 線程之間的通信問題：生產者和消費者問題 等待喚醒，通知喚醒 線程交替執行 A B 操作同一個變量number=0 A num+1 B num-1 * */public class A { public static void main(String[] args) { Data data =new Data(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.increment(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"A").start(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.decrement(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"B").start(); }}//判斷等待+業務+通知class Data{ //數字。資源類 private int number=0; //+1。多線程的情況下一定要加鎖。 public synchronized void increment() throws InterruptedException{ //判斷是否需要等待，如果不需要，就需要干活進行業務操作 if(number!=0){ //等于1的時候，需要等待，緩沖區只有1個空位置 //等待操作 this.wait(); } number++; //進行業務操作 System.out.println(Thread.currentThread().getName()+"=>"+number); //通知其他線程，我+1完畢了 this.notify(); } //-1 public synchronized void decrement() throws InterruptedException{ if(number==0){ //等待 this.wait(); } number--; System.out.println(Thread.currentThread().getName()+"=>"+number); //通知其他線程，我-1完畢了 this.notify(); }}
如圖，基本可以實現所要求的功能，但是這樣還會出現問題，如果此時我再加上了兩個線程，則
new Thread(()->{ for(int i=0;i<10;i++){ try { data.increment(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"C").start(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.decrement(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"D").start();
這里結果中出現了2，輸出結果出現了問題。為什么呢？
為什么if判斷會出現問題：
if判斷只判斷一次。因為if判斷了之后，就已經進入了代碼的等待那一行，這時，在wait下的線程可能有多個，甚至包括生產者和消費者。有可能某個生產者執行完了之后，喚醒的是另一個生產者。
在我們的官方文檔中就給出了解釋
public final void wait(long timeout) throws InterruptedException
導致當前線程等待，直到另一個線程調用此對象的notify()方法或notifyAll()方法，或指定的時間已過。
線程也可以喚醒，而不會被通知，中斷或超時，即所謂的虛假喚醒 。 雖然這在實踐中很少會發生，但應用程序必須通過測試應該使線程被喚醒的條件來防范，并且如果條件不滿足則繼續等待。 換句話說，等待應該總是出現在循環中，就像這樣：
synchronized (obj) { while (<condition does not hold>) obj.wait(timeout); ... // Perform action appropriate to condition }
注意點：防止虛假喚醒問題。
我們代碼中用的是if判斷，而應該用while判斷
package testConcurrent;/* 線程之間的通信問題：生產者和消費者問題 等待喚醒，通知喚醒 線程交替執行 A B 操作同一個變量number=0 A num+1 B num-1 * */public class A { public static void main(String[] args) { Data data =new Data(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.increment(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"A").start(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.decrement(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"B").start(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.increment(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"C").start(); new Thread(()->{ for(int i=0;i<10;i++){ try { data.decrement(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } } },"D").start(); }}//判斷等待+業務+通知class Data{ //數字。資源類 private int number=0; //+1 public synchronized void increment() throws InterruptedException{ //判斷是否需要等待，如果不需要，就需要干活進行業務操作 while(number!=0){ //等于1的時候，需要等待，緩沖區只有1個空位置 //等待操作 this.wait(); } number++; //進行業務操作 System.out.println(Thread.currentThread().getName()+"=>"+number); //通知其他線程，我+1完畢了 this.notify(); } //-1 public synchronized void decrement() throws InterruptedException{ while(number==0){ //等待 this.wait(); } number--; System.out.println(Thread.currentThread().getName()+"=>"+number); //通知其他線程，我-1完畢了 this.notify(); }}
Lock版的生產者和消費者問題
在synchronized版本中，我們使用了wait和notify來實現線程之間的同步
在lock中，
此時synchronized被lock替換了，那么wait和notify用什么來替換呢？
我們在官方文檔java.util.concurrent.locks 中，找到Lock類，然后在底部找到了
Condition newCondition()
返回一個新Condition綁定到該實例Lock實例。
在等待條件之前，鎖必須由當前線程保持。 呼叫Condition.await()將在等待之前將原子釋放鎖，并在等待返回之前重新獲取鎖。
然后我們再來了解Condition類
Condition 將 Object 監視器方法（wait、notify 和 notifyAll）分解成截然不同的對象，以便通過將這些對象與任意 Lock 實現組合使用，為每個對象提供多個等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和語句的使用，Condition 替代了 Object 監視器方法的使用。
一個Condition實例本質上綁定到一個鎖。 要獲得特定Condition實例的Condition實例，請使用其newCondition()方法。
我們可以看到，使用的時候new一個Condition對象。然后用await替代wait,signal替換notify
代碼實現
//判斷等待+業務+通知
class Data2{ //數字。資源類 private int number=0; Lock lock=new ReentrantLock(); Condition condition=lock.newCondition(); //+1 public void increment() throws InterruptedException{ try { lock.lock(); //業務代碼 while(number!=0){ //等待 condition.await(); } number++; System.out.println(Thread.currentThread().getName()+"=>"+number); condition.signalAll(); //通知 } catch (Exception e) { // TODO: handle exception }finally{ lock.unlock(); } } //-1 public void decrement() throws InterruptedException{ try { lock.lock(); //業務代碼 while(number!=1){ //等待 condition.await(); } number--; System.out.println(Thread.currentThread().getName()+"=>"+number); condition.signalAll(); //通知 } catch (Exception e) { // TODO: handle exception }finally{ lock.unlock(); } } }
注意：主函數部分于最上面的代碼一樣。
這時候雖然說是正確的，但是它是一個隨機分布的狀態，現在我們希望它有序執行，即A執行完了執行B，B執行C，C完了執行D。即精準通知。
Condition實現精準通知喚醒
Condition實現精準的通知和喚醒
我們構造三個線程，要求A執行完了執行B，B執行完了執行C，C執行完了執行D.
代碼思想：
//加多個監視器，通過監視器來判斷喚醒的是哪一個人
//設置多個同步監視器，每個監視器監視一個線程
//實例：生產線，下單->支付->交易->物流
package testConcurrent;import java.util.concurrent.locks.Condition;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReentrantLock;/* A執行完調用B,B執行完調用C，C執行完調用A * */public class C { public static void main(String[] args) { Data3 data=new Data3(); new Thread(()->{ for(int i=0;i<10;i++){ data.printA(); } },"A").start(); new Thread(()->{ for(int i=0;i<10;i++){ data.printB(); } },"B").start(); new Thread(()->{ for(int i=0;i<10;i++){ data.printC(); } },"C").start(); }}class Data3{ //資源類 private Lock lock=new ReentrantLock(); //加多個監視器，通過監視器來判斷喚醒的是哪一個人 //設置多個同步監視器，每個監視器監視一個線程 //實例：生產線，下單->支付->交易->物流 private Condition condition1=lock.newCondition(); private Condition condition2=lock.newCondition(); private Condition condition3=lock.newCondition(); private int number=1; //1A 2B 3C public void printA(){ lock.lock(); try { //業務，判斷->執行->通知 while(number!=1){ //等待 condition1.await(); } System.out.println(Thread.currentThread().getName()+"=>AAAAAAA"); //喚醒，喚醒指定的人，B number=2; //精準喚醒 condition2.signal(); } catch (Exception e) { // TODO: handle exception }finally{ lock.unlock(); } } public void printB(){ lock.lock(); try { //業務，判斷->執行->通知 while(number!=2){ //等待 condition2.await(); } System.out.println(Thread.currentThread().getName()+"=>BBBBBBB"); //喚醒，喚醒指定的人，C number=3; //精準喚醒 condition3.signal(); } catch (Exception e) { // TODO: handle exception }finally{ lock.unlock(); } } public void printC(){ lock.lock(); try { //業務，判斷->執行->通知 while(number!=3){ //等待 condition3.await(); } System.out.println(Thread.currentThread().getName()+"=>CCCCCCC"); //喚醒，喚醒指定的人，A number=1; //精準喚醒 condition1.signal(); } catch (Exception e) { // TODO: handle exception }finally{ lock.unlock(); } }}
相關學習推薦：java基礎
