高并發場景下怎么優化加鎖方式

本篇內容介紹了“高并發場景下怎么優化加鎖方式”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

例如在我們完成轉賬操作的過程中，我們一次性申請賬戶A和賬戶B，兩個賬戶都申請成功后，再執行轉賬的操作。其中，在我們實現的轉賬方法中，使用了死循環來循環獲取資源，直到同時獲取到賬戶A和賬戶B為止，核心代碼如下所示。

//一次申請轉出賬戶和轉入賬戶，直到成功 while(!requester.applyResources(this, target)){     //循環體為空     ; }

如果ResourcesRequester類的applyResources()方法執行的時間非常短，并且程序并發帶來的沖突不大，程序循環幾次到幾十次就可以同時獲取到轉出賬戶和轉入賬戶，這種方案就是可行的。

但是，如果ResourcesRequester類的applyResources()方法執行的時間比較長，或者說，程序并發帶來的沖突比較大，此時，可能需要循環成千上萬次才能同時獲取到轉出賬戶和轉入賬戶。這樣就太消耗CPU資源了，此時，這種方案就是不可行的了。

那么，有沒有什么方式對這種方案進行優化呢?

問題分析

既然使用死循環一直獲取資源這種方案存在問題，那我們換位思考一下。當線程執行時，發現條件不滿足，是不是可以讓線程進入等待狀態?當條件滿足的時候，通知等待的線程重新執行?

也就是說，如果線程需要的條件不滿足，我們就讓線程進入等待狀態;如果線程需要的條件滿足時，我們再通知等待的線程重新執行。這樣，就能夠避免程序進行循環等待進而消耗CPU的問題。

那么，問題又來了!當條件不滿足時，如何實現讓線程等待?當條件滿足時，又如何喚醒線程呢?

不錯，這是個問題!不過這個問題解決起來也非常簡單。簡單的說，就是使用線程的等待與通知機制。

線程的等待與通知機制

我們可以使用線程的等待與通知機制來優化阻止請求與保持條件時，循環獲取賬戶資源的問題。具體的等待與通知機制如下所示。

執行的線程首先獲取互斥鎖，如果線程繼續執行時，需要的條件不滿足，則釋放互斥鎖，并進入等待狀態;當線程繼續執行需要的條件滿足時，就通知等待的線程，重新獲取互斥鎖。

那么，說了這么多，Java支持這種線程的等待與通知機制嗎?其實，這個問題問的就有點廢話了，Java這么優秀(牛逼)的語言肯定支持啊，而且實現起來也比較簡單。

Java實現線程的等待與通知機制

實現方式

其實，使用Java語言實現線程的等待與通知機制有多種方式，這里我就簡單的列舉一種方式，其他的方式大家可以自行思考和實現，有不懂的地方也可以問我!

在Java語言中，實現線程的等待與通知機制，一種簡單的方式就是使用synchronized并結合wait()、notify()和notifyAll()方法來實現。

實現原理

我們使用synchronized加鎖時，只允許一個線程進入synchronized保護的代碼塊，也就是臨界區。如果一個線程進入了臨界區，則其他的線程會進入阻塞隊列里等待，這個阻塞隊列和synchronized互斥鎖是一對一的關系，也就是說，一把互斥鎖對應著一個獨立的阻塞隊列。

在并發編程中，如果一個線程獲得了synchronized互斥鎖，但是不滿足繼續向下執行的條件，則需要進入等待狀態。此時，可以使用Java中的wait()方法來實現。當調用wait()方法后，當前線程就會被阻塞，并且會進入一個等待隊列中進行等待，這個由于調用wait()方法而進入的等待隊列也是互斥鎖的等待隊列。而且，線程在進入等待隊列的同時，會釋放自身獲得的互斥鎖，這樣，其他線程就有機會獲得互斥鎖，進而進入臨界區了。整個過程可以表示成下圖所示。

當線程執行的條件滿足時，可以使用Java提供的notify()和notifyAll()方法來通知互斥鎖等待隊列中的線程，我們可以使用下圖來簡單的表示這個過程。

這里，需要注意如下事項：

(1)使用notify()和notifyAll()方法通知線程時，調用notify()和notifyAll()方法時，滿足線程的執行條件，但是當線程真正執行的時候，條件可能已經不再滿足了，可能有其他線程已經進入臨界區執行。

(2)被通知的線程繼續執行時，需要先獲取互斥鎖，因為在調用wait()方法等待時已經釋放了互斥鎖。

(3)wait()、notify()和notifyAll()方法操作的隊列是互斥鎖的等待隊列，如果synchronized鎖定的是this對象，則一定要使用this.wait()、this.notify()和this.notifyAll()方法;如果synchronized鎖定的是target對象，則一定要使用target.wait()、target.notify()和target.notifyAll()方法。

(4)wait()、notify()和notifyAll()方法調用的前提是已經獲取了相應的互斥鎖，也就是說，wait()、notify()和notifyAll()方法都是在synchronized方法中或代碼塊中調用的。如果在synchronized方法外或代碼塊外調用了三個方法，或者鎖定的對象是this，使用target對象調用三個方法的話，JVM會拋出java.lang.IllegalMonitorStateException異常。

具體實現

實現邏輯

在實現之前，我們還需要考慮以下幾個問題：

• 選擇哪個互斥鎖

在之前的程序中，我們在TansferAccount類中，存在一個ResourcesRequester  類的單例對象，所以，我們是可以使用this作為互斥鎖的。這一點大家需要重點理解。

• 線程執行轉賬操作的條件

轉出賬戶和轉入賬戶都沒有被分配過。

• 線程什么時候進入等待狀態

線程繼續執行需要的條件不滿足的時候，進入等待狀態。

• 什么時候通知等待的線程執行

當存在線程釋放賬戶的資源時，通知等待的線程繼續執行。

綜上，我們可以得出以下核心代碼。

while(不滿足條件){     wait(); }

那么，問題來了!為何是在while循環中調用wait()方法呢?因為當wait()方法返回時，有可能線程執行的條件已經改變，也就是說，之前條件是滿足的，但是現在已經不滿足了，所以要重新檢驗條件是否滿足。

實現代碼

我們優化后的ResourcesRequester類的代碼如下所示。

public class ResourcesRequester{     //存放申請資源的集合     private List<Object> resources = new ArrayList<Object>();     //一次申請所有的資源     public synchronized void applyResources(Object source, Object target){         while(resources.contains(source) || resources.contains(target)){             try{                 wait();             }catch(Exception e){                 e.printStackTrace();             }         }         resources.add(source);         resources.add(targer);     }          //釋放資源     public synchronized void releaseResources(Object source, Object target){         resources.remove(source);         resources.remove(target);         notifyAll();     } }

生成ResourcesRequester單例對象的Holder類ResourcesRequesterHolder的代碼如下所示。

public class ResourcesRequesterHolder{     private ResourcesRequesterHolder(){}          public static ResourcesRequester getInstance(){         return Singleton.INSTANCE.getInstance();     }     private enum Singleton{         INSTANCE;         private ResourcesRequester singleton;         Singleton(){             singleton = new ResourcesRequester();         }         public ResourcesRequester getInstance(){             return singleton;         }     } }

執行轉賬操作的類的代碼如下所示。

public class TansferAccount{     //賬戶的余額     private Integer balance;     //ResourcesRequester類的單例對象     private ResourcesRequester requester;         public TansferAccount(Integer balance){         this.balance = balance;         this.requester = ResourcesRequesterHolder.getInstance();     }     //轉賬操作     public void transfer(TansferAccount target, Integer transferMoney){         //一次申請轉出賬戶和轉入賬戶，直到成功         requester.applyResources(this, target))         try{             //對轉出賬戶加鎖             synchronized(this){                 //對轉入賬戶加鎖                 synchronized(target){                     if(this.balance >= transferMoney){                         this.balance -= transferMoney;                         target.balance += transferMoney;                     }                    }             }         }finally{             //最后釋放賬戶資源             requester.releaseResources(this, target);         }     } }

可以看到，我們在程序中通知處于等待狀態的線程時，使用的是notifyAll()方法而不是notify()方法。那notify()方法和notifyAll()方法兩者有什么區別呢?

notify()和notifyAll()的區別

• notify()方法

隨機通知等待隊列中的一個線程。

• notifyAll()方法

通知等待隊列中的所有線程。

在實際工作過程中，如果沒有特殊的要求，盡量使用notifyAll()方法。因為使用notify()方法是有風險的，可能會導致某些線程永久不會被通知到!

“高并發場景下怎么優化加鎖方式”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！