2. 程式人生 > >多執行緒常用面試題

多執行緒常用面試題

阿新 • • 發佈：2018-12-01

一 面試中關於 synchronized 關鍵字的 5 連擊

1.1 說一說自己對於 synchronized 關鍵字的瞭解 

synchronized關鍵字解決的是多個執行緒之間訪問資源的同步性，synchronized關鍵字可以保證被它修飾的方法或者程式碼塊在任意時刻只能有一個執行緒執行。

另外，在 Java 早期版本中，synchronized屬於重量級鎖，效率低下，因為監視器鎖（monitor）是依賴於底層的作業系統的 Mutex Lock 來實現的，Java 的執行緒是對映到作業系統的原生執行緒之上的。如果要掛起或者喚醒一個執行緒，都需要作業系統幫忙完成，而作業系統實現執行緒之間的切換時需要從使用者態轉換到核心態，這個狀態之間的轉換需要相對比較長的時間，時間成本相對較高，這也是為什麼早期的 synchronized 效率低的原因。慶幸的是在 Java 6 之後 Java 官方對從 JVM 層面對synchronized 較大優化，所以現在的 synchronized 鎖效率也優化得很不錯了。JDK1.6對鎖的實現引入了大量的優化，如自旋鎖、適應性自旋鎖、鎖消除、鎖粗化、偏向鎖、輕量級鎖等技術來減少鎖操作的開銷。

 1.2 說說自己是怎麼使用 synchronized 關鍵字，在專案中用到了嗎

synchronized關鍵字最主要的三種使用方式：

  • 修飾例項方法，作用於當前物件例項加鎖，進入同步程式碼前要獲得當前物件例項的鎖
  • 修飾靜態方法，作用於當前類物件加鎖，進入同步程式碼前要獲得當前類物件的鎖 。也就是給當前類加鎖，會作用於類的所有物件例項，因為靜態成員不屬於任何一個例項物件，是類成員（ static 表明這是該類的一個靜態資源，不管new了多少個物件，只有一份，所以對該類的所有物件都加了鎖）。所以如果一個執行緒A呼叫一個例項物件的非靜態 synchronized 方法，而執行緒B需要呼叫這個例項物件所屬類的靜態 synchronized 方法，是允許的，不會發生互斥現象，因為訪問靜態 synchronized 方法佔用的鎖是當前類的鎖，而訪問非靜態 synchronized 方法佔用的鎖是當前例項物件鎖。
  • 修飾程式碼塊，指定加鎖物件，對給定物件加鎖，進入同步程式碼庫前要獲得給定物件的鎖。 和 synchronized 方法一樣，synchronized(this)程式碼塊也是鎖定當前物件的。synchronized 關鍵字加到 static 靜態方法和 synchronized(class)程式碼塊上都是是給 Class 類上鎖。這裡再提一下：synchronized關鍵字加到非 static 靜態方法上是給物件例項上鎖。另外需要注意的是：儘量不要使用 synchronized(String a) 因為JVM中，字串常量池具有緩衝功能！

下面我已一個常見的面試題為例講解一下 synchronized 關鍵字的具體使用。

面試中面試官經常會說：“單例模式瞭解嗎？來給我手寫一下！給我解釋一下雙重檢驗鎖方式實現單利模式的原理唄！”

雙重校驗鎖實現物件單例（執行緒安全） 

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
       //先判斷物件是否已經例項過，沒有例項化過才進入加鎖程式碼
        if (uniqueInstance == null) {
            //類物件加鎖
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

另外，需要注意 uniqueInstance 採用 volatile 關鍵字修飾也是很有必要。

uniqueInstance 採用 volatile 關鍵字修飾也是很有必要的， uniqueInstance = new Singleton(); 這段程式碼其實是分為三步執行：

  • 為 uniqueInstance 分配記憶體空間
  • 初始化 uniqueInstance
  • 將 uniqueInstance 指向分配的記憶體地址

但是由於 JVM 具有指令重排的特性，執行順序有可能變成 1->3->2。指令重排在單執行緒環境下不會出先問題，但是在多執行緒環境下會導致一個執行緒獲得還沒有初始化的例項。

例如，執行緒 T1 執行了 1 和 3，此時 T2 呼叫 getUniqueInstance() 後發現 uniqueInstance 不為空，因此返回 uniqueInstance，但此時 uniqueInstance 還未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保證在多執行緒環境下也能正常執行。

 1.3 講一下 synchronized 關鍵字的底層原理

synchronized 關鍵字底層原理屬於 JVM 層面。

① synchronized 同步語句塊的情況

public class SynchronizedDemo {
	public void method() {
		synchronized (this) {
			System.out.println("synchronized 程式碼塊");
		}
	}
}

通過 JDK 自帶的 javap 命令檢視 SynchronizedDemo 類的相關位元組碼資訊：首先切換到類的對應目錄執行 javac SynchronizedDemo.java 命令生成編譯後的 .class 檔案，然後執行javap -c -s -v -l SynchronizedDemo.class。

synchronized å³é®å­åç

從上面我們可以看出：

synchronized 同步語句塊的實現使用的是 monitorenter 和 monitorexit 指令，其中 monitorenter 指令指向同步程式碼塊的開始位置，monitorexit 指令則指明同步程式碼塊的結束位置。 當執行 monitorenter 指令時，執行緒試圖獲取鎖也就是獲取 monitor(monitor物件存在於每個Java物件的物件頭中，synchronized 鎖便是通過這種方式獲取鎖的，也是為什麼Java中任意物件可以作為鎖的原因) 的持有權.當計數器為0則可以成功獲取，獲取後將鎖計數器設為1也就是加1。相應的在執行 monitorexit 指令後，將鎖計數器設為0，表明鎖被釋放。如果獲取物件鎖失敗，那當前執行緒就要阻塞等待，直到鎖被另外一個執行緒釋放為止。

② synchronized 修飾方法的的情況

public class SynchronizedDemo2 {
	public synchronized void method() {
		System.out.println("synchronized 方法");
	}
}

synchronized å³é®å­åç

synchronized 修飾的方法並沒有 monitorenter 指令和 monitorexit 指令，取得代之的確實是 ACC_SYNCHRONIZED 標識，該標識指明瞭該方法是一個同步方法，JVM 通過該 ACC_SYNCHRONIZED 訪問標誌來辨別一個方法是否宣告為同步方法，從而執行相應的同步呼叫。

1.4 說說 JDK1.6 之後的synchronized 關鍵字底層做了哪些優化，可以詳細介紹一下這些優化嗎 

JDK1.6 對鎖的實現引入了大量的優化，如偏向鎖、輕量級鎖、自旋鎖、適應性自旋鎖、鎖消除、鎖粗化等技術來減少鎖操作的開銷。

鎖主要存在四中狀態，依次是：無鎖狀態、偏向鎖狀態、輕量級鎖狀態、重量級鎖狀態，他們會隨著競爭的激烈而逐漸升級。注意鎖可以升級不可降級，這種策略是為了提高獲得鎖和釋放鎖的效率。

關於這幾種優化的詳細資訊可以檢視：synchronized 關鍵字使用、底層原理、JDK1.6 之後的底層優化以及 和ReenTrantLock 的對比

 1.5 談談 synchronized和ReenTrantLock 的區別

① 兩者都是可重入鎖

兩者都是可重入鎖。“可重入鎖”概念是：自己可以再次獲取自己的內部鎖。比如一個執行緒獲得了某個物件的鎖，此時這個物件鎖還沒有釋放，當其再次想要獲取這個物件的鎖的時候還是可以獲取的，如果不可鎖重入的話，就會造成死鎖。同一個執行緒每次獲取鎖，鎖的計數器都自增1，所以要等到鎖的計數器下降為0時才能釋放鎖。

② synchronized 依賴於 JVM 而 ReenTrantLock 依賴於 API

synchronized 是依賴於 JVM 實現的，前面我們也講到了 虛擬機器團隊在 JDK1.6 為 synchronized 關鍵字進行了很多優化，但是這些優化都是在虛擬機器層面實現的，並沒有直接暴露給我們。ReenTrantLock 是 JDK 層面實現的（也就是 API 層面，需要 lock() 和 unlock 方法配合 try/finally 語句塊來完成），所以我們可以通過檢視它的原始碼，來看它是如何實現的。

③ ReenTrantLock 比 synchronized 增加了一些高階功能

相比synchronized，ReenTrantLock增加了一些高階功能。主要來說主要有三點：①等待可中斷；②可實現公平鎖；③可實現選擇性通知（鎖可以繫結多個條件）

  • ReenTrantLock提供了一種能夠中斷等待鎖的執行緒的機制，通過lock.lockInterruptibly()來實現這個機制。也就是說正在等待的執行緒可以選擇放棄等待，改為處理其他事情。
  • ReenTrantLock可以指定是公平鎖還是非公平鎖。而synchronized只能是非公平鎖。所謂的公平鎖就是先等待的執行緒先獲得鎖。 ReenTrantLock預設情況是非公平的，可以通過 ReenTrantLock類的ReentrantLock(boolean fair)構造方法來制定是否是公平的。
  • synchronized關鍵字與wait()和notify/notifyAll()方法相結合可以實現等待/通知機制，ReentrantLock類當然也可以實現，但是需要藉助於Condition介面與newCondition() 方法。Condition是JDK1.5之後才有的，它具有很好的靈活性，比如可以實現多路通知功能也就是在一個Lock物件中可以建立多個Condition例項（即物件監視器），執行緒物件可以註冊在指定的Condition中，從而可以有選擇性的進行執行緒通知，在排程執行緒上更加靈活。 在使用notify/notifyAll()方法進行通知時，被通知的執行緒是由 JVM 選擇的，用ReentrantLock類結合Condition例項可以實現“選擇性通知” ，這個功能非常重要，而且是Condition介面預設提供的。而synchronized關鍵字就相當於整個Lock物件中只有一個Condition例項，所有的執行緒都註冊在它一個身上。如果執行notifyAll()方法的話就會通知所有處於等待狀態的執行緒這樣會造成很大的效率問題，而Condition例項的signalAll()方法 只會喚醒註冊在該Condition例項中的所有等待執行緒。

如果你想使用上述功能，那麼選擇ReenTrantLock是一個不錯的選擇。

 二 面試中關於執行緒池的 4 連擊

2.1 講一下Java記憶體模型 

在 JDK1.2 之前，Java的記憶體模型實現總是從主存（即共享記憶體）讀取變數，是不需要進行特別的注意的。而在當前的 Java 記憶體模型下，執行緒可以把變數儲存本地記憶體（比如機器的暫存器）中，而不是直接在主存中進行讀寫。這就可能造成一個執行緒在主存中修改了一個變數的值，而另外一個執行緒還繼續使用它在暫存器中的變數值的拷貝，造成資料的不一致。

æ°æ®çä¸ä¸è´

要解決這個問題，就需要把變數宣告為 volatile，這就指示 JVM，這個變數是不穩定的，每次使用它都到主存中進行讀取。

說白了， volatile 關鍵字的主要作用就是保證變數的可見性然後還有一個作用是防止指令重排序。

 

 volatileå³é®å­çå¯è§æ§

2.2 說說 synchronized 關鍵字和 volatile 關鍵字的區別

synchronized關鍵字和volatile關鍵字比較

  • volatile關鍵字是執行緒同步的輕量級實現，所以volatile效能肯定比synchronized關鍵字要好。但是volatile關鍵字只能用於變數而synchronized關鍵字可以修飾方法以及程式碼塊。synchronized關鍵字在JavaSE1.6之後進行了主要包括為了減少獲得鎖和釋放鎖帶來的效能消耗而引入的偏向鎖和輕量級鎖以及其它各種優化之後執行效率有了顯著提升，實際開發中使用 synchronized 關鍵字的場景還是更多一些。
  • 多執行緒訪問volatile關鍵字不會發生阻塞，而synchronized關鍵字可能會發生阻塞
  • volatile關鍵字能保證資料的可見性，但不能保證資料的原子性。synchronized關鍵字兩者都能保證。
  • volatile關鍵字主要用於解決變數在多個執行緒之間的可見性，而 synchronized關鍵字解決的是多個執行緒之間訪問資源的同步性。

 三 面試中關於 執行緒池的 2 連擊

3.1 為什麼要用執行緒池？

執行緒池提供了一種限制和管理資源（包括執行一個任務）。 每個執行緒池還維護一些基本統計資訊，例如已完成任務的數量。

這裡借用《Java併發程式設計的藝術》提到的來說一下使用執行緒池的好處：

  • 降低資源消耗。 通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。
  • 提高響應速度。 當任務到達時，任務可以不需要的等到執行緒建立就能立即執行。
  • 提高執行緒的可管理性。 執行緒是稀缺資源，如果無限制的建立，不僅會消耗系統資源，還會降低系統的穩定性，使用執行緒池可以進行統一的分配，調優和監控。

3.2 實現Runnable介面和Callable介面的區別

如果想讓執行緒池執行任務的話需要實現的Runnable介面或Callable介面。 Runnable介面或Callable介面實現類都可以被ThreadPoolExecutor或ScheduledThreadPoolExecutor執行。兩者的區別在於 Runnable 介面不會返回結果但是 Callable 介面可以返回結果。

備註： 工具類Executors可以實現Runnable物件和Callable物件之間的相互轉換。（Executors.callable（Runnable task）或Executors.callable（Runnable task，Object resule））。

3.3 執行execute()方法和submit()方法的區別是什麼呢？

1)execute() 方法用於提交不需要返回值的任務，所以無法判斷任務是否被執行緒池執行成功與否；

2)submit()方法用於提交需要返回值的任務。執行緒池會返回一個future型別的物件，通過這個future物件可以判斷任務是否執行成功，並且可以通過future的get()方法來獲取返回值，get()方法會阻塞當前執行緒直到任務完成，而使用 get（long timeout，TimeUnit unit）方法則會阻塞當前執行緒一段時間後立即返回，這時候有可能任務沒有執行完。

3.4 如何建立執行緒池

《阿里巴巴Java開發手冊》中強制執行緒池不允許使用 Executors 去建立，而是通過 ThreadPoolExecutor 的方式，這樣的處理方式讓寫的同學更加明確執行緒池的執行規則，規避資源耗盡的風險**

 Executors 返回執行緒池物件的弊端如下：

  • FixedThreadPool 和 SingleThreadExecutor ： 允許請求的佇列長度為 Integer.MAX_VALUE,可能堆積大量的請求，從而導致OOM。
  • CachedThreadPool 和 ScheduledThreadPool ： 允許建立的執行緒數量為 Integer.MAX_VALUE ，可能會建立大量執行緒，從而導致OOM。

方式一：通過構造方法實現

éè¿æé æ¹æ³å®ç°

方式二：通過Executor 框架的工具類Executors來實現
我們可以建立三種類型的ThreadPoolExecutor：

FixedThreadPool ： 該方法返回一個固定執行緒數量的執行緒池。該執行緒池中的執行緒數量始終不變。當有一個新的任務提交時，執行緒池中若有空閒執行緒，則立即執行。若沒有，則新的任務會被暫存在一個任務佇列中，待有執行緒空閒時，便處理在任務佇列中的任務。
SingleThreadExecutor： 方法返回一個只有一個執行緒的執行緒池。若多餘一個任務被提交到該執行緒池，任務會被儲存在一個任務佇列中，待執行緒空閒，按先入先出的順序執行佇列中的任務。
CachedThreadPool： 該方法返回一個可根據實際情況調整執行緒數量的執行緒池。執行緒池的執行緒數量不確定，但若有空閒執行緒可以複用，則會優先使用可複用的執行緒。若所有執行緒均在工作，又有新的任務提交，則會建立新的執行緒處理任務。所有執行緒在當前任務執行完畢後，將返回執行緒池進行復用。

對應Executors工具類中的方法如圖所示：

 éè¿Executor æ¡æ¶çå·¥å·ç±»Executorsæ¥å®ç°

四 面試中關於 Atomic 原子類的 4 連擊

4.1 介紹一下Atomic 原子類

Atomic 翻譯成中文是原子的意思。在化學上，我們知道原子是構成一般物質的最小單位，在化學反應中是不可分割的。在我們這裡 Atomic 是指一個操作是不可中斷的。即使是在多個執行緒一起執行的時候，一個操作一旦開始，就不會被其他執行緒干擾。

所以，所謂原子類說簡單點就是具有原子/原子操作特徵的類。

併發包 java.util.concurrent 的原子類都存放在java.util.concurrent.atomic下,如下圖所示。

JUC åå­ç±»æ¦è§

4.2 JUC 包中的原子類是哪4類?

基本型別

使用原子的方式更新基本型別

AtomicInteger：整形原子類
AtomicLong：長整型原子類
AtomicBoolean ：布林型原子類
陣列型別

使用原子的方式更新數組裡的某個元素

  • AtomicIntegerArray：整形陣列原子類
  • AtomicLongArray：長整形陣列原子類
  • AtomicReferenceArray ：引用型別陣列原子類

引用型別

  • AtomicReference：引用型別原子類
  • AtomicStampedRerence：原子更新引用型別裡的欄位原子類
  • AtomicMarkableReference ：原子更新帶有標記位的引用型別

物件的屬性修改型別

  • AtomicIntegerFieldUpdater:原子更新整形欄位的更新器
  • AtomicLongFieldUpdater：原子更新長整形欄位的更新器
  • AtomicStampedReference ：原子更新帶有版本號的引用型別。該類將整數值與引用關聯起來，可用於解決原子的更新資料和資料的版本號，可以解決使用 CAS 進行原子更新時可能出現的 ABA 問題。

4.3 講講 AtomicInteger 的使用

AtomicInteger 類常用方法

public final int get() //獲取當前的值
public final int getAndSet(int newValue)//獲取當前的值，並設定新的值
public final int getAndIncrement()//獲取當前的值，並自增
public final int getAndDecrement() //獲取當前的值，並自減
public final int getAndAdd(int delta) //獲取當前的值，並加上預期的值
boolean compareAndSet(int expect, int update) //如果輸入的數值等於預期值，則以原子方式將該值設定為輸入值（update）
public final void lazySet(int newValue)//最終設定為newValue,使用 lazySet 設定之後可能導致其他執行緒在之後的一小段時間內還是可以讀到舊的值。

AtomicInteger 類的使用示例

使用 AtomicInteger 之後，不用對 increment() 方法加鎖也可以保證執行緒安全。

class AtomicIntegerTest {
        private AtomicInteger count = new AtomicInteger();
      //使用AtomicInteger之後，不需要對該方法加鎖，也可以實現執行緒安全。
        public void increment() {
                  count.incrementAndGet();
        }
     
       public int getCount() {
                return count.get();
        }
}

4.4 能不能給我簡單介紹一下 AtomicInteger 類的原理

AtomicInteger 執行緒安全原理簡單分析

AtomicInteger 類的部分原始碼：

// setup to use Unsafe.compareAndSwapInt for updates（更新操作時提供“比較並替換”的作用）
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
    try {
        valueOffset = unsafe.objectFieldOffset
                (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

AtomicInteger 類主要利用 CAS (compare and swap) + volatile 和 native 方法來保證原子操作，從而避免 synchronized 的高開銷，執行效率大為提升。

CAS的原理是拿期望的值和原本的一個值作比較，如果相同則更新成新的值。UnSafe 類的 objectFieldOffset() 方法是一個本地方法，這個方法是用來拿到“原來的值”的記憶體地址，返回值是 valueOffset。另外 value 是一個volatile變數，在記憶體中可見，因此 JVM 可以保證任何時刻任何執行緒總能拿到該變數的最新值。

關於 Atomic 原子類這部分更多內容可以檢視：https://mp.weixin.qq.com/s/joa-yOiTrYF67bElj8xqvg

五 AQS 

5.1 AQS 介紹 

enter image description here

AQS是一個用來構建鎖和同步器的框架，使用AQS能簡單且高效地構造出應用廣泛的大量的同步器，比如我們提到的ReentrantLock，Semaphore，其他的諸如ReentrantReadWriteLock，SynchronousQueue，FutureTask等等皆是基於AQS的。當然，我們自己也能利用AQS非常輕鬆容易地構造出符合我們自己需求的同步器。

5.2 AQS 原理分析

AQS 原理這部分參考了部分部落格，在5.2節末尾放了連結。

在面試中被問到併發知識的時候，大多都會被問到“請你說一下自己對於AQS原理的理解”。下面給大家一個示例供大家參加，面試不是背題，大家一定要假如自己的思想，即使加入不了自己的思想也要保證自己能夠通俗的講出來而不是背出來。

下面大部分內容其實在AQS類註釋上已經給出了，不過是英語看著比較吃力一點，感興趣的話可以看看原始碼。

5.2.1 AQS 原理概覽

AQS核心思想是，如果被請求的共享資源空閒，則將當前請求資源的執行緒設定為有效的工作執行緒，並且將共享資源設定為鎖定狀態。如果被請求的共享資源被佔用，那麼就需要一套執行緒阻塞等待以及被喚醒時鎖分配的機制，這個機制AQS是用CLH佇列鎖實現的，即將暫時獲取不到鎖的執行緒加入到佇列中。

CLH(Craig,Landin,and Hagersten)佇列是一個虛擬的雙向佇列（虛擬的雙向佇列即不存在佇列例項，僅存在結點之間的關聯關係）。AQS是將每條請求共享資源的執行緒封裝成一個CLH鎖佇列的一個結點（Node）來實現鎖的分配。

看個AQS(AbstractQueuedSynchronizer)原理圖：

 enter image description here

AQS使用一個int成員變數來表示同步狀態，通過內建的FIFO佇列來完成獲取資源執行緒的排隊工作。AQS使用CAS對該同步狀態進行原子操作實現對其值的修改。 

private volatile int state;//共享變數，使用volatile修飾保證執行緒可見性

 狀態資訊通過procted型別的getState，setState，compareAndSetState進行操作

//返回同步狀態的當前值
protected final int getState() {  
        return state;
}
 // 設定同步狀態的值
protected final void setState(int newState) { 
        state = newState;
}
//原子地（CAS操作）將同步狀態值設定為給定值update如果當前同步狀態的值等於expect（期望值）
protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}

5.2.2 AQS 對資源的共享方式

AQS定義兩種資源共享方式

  • Exclusive（獨佔）：只有一個執行緒能執行，如ReentrantLock。又可分為公平鎖和非公平鎖：
    • 公平鎖：按照執行緒在佇列中的排隊順序，先到者先拿到鎖
    • 非公平鎖：當執行緒要獲取鎖時，無視佇列順序直接去搶鎖，誰搶到就是誰的
  • Share（共享）：多個執行緒可同時執行，如Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我們都會在後面講到。

ReentrantReadWriteLock 可以看成是組合式，因為ReentrantReadWriteLock也就是讀寫鎖允許多個執行緒同時對某一資源進行讀。

不同的自定義同步器爭用共享資源的方式也不同。自定義同步器在實現時只需要實現共享資源 state 的獲取與釋放方式即可，至於具體執行緒等待佇列的維護（如獲取資源失敗入隊/喚醒出隊等），AQS已經在頂層實現好了。

5.2.3 AQS底層使用了模板方法模式

同步器的設計是基於模板方法模式的，如果需要自定義同步器一般的方式是這樣（模板方法模式很經典的一個應用）：

  • 使用者繼承AbstractQueuedSynchronizer並重寫指定的方法。（這些重寫方法很簡單，無非是對於共享資源state的獲取和釋放）
  • 將AQS組合在自定義同步元件的實現中，並呼叫其模板方法，而這些模板方法會呼叫使用者重寫的方法。

這和我們以往通過實現介面的方式有很大區別，這是模板方法模式很經典的一個運用。

AQS使用了模板方法模式，自定義同步器時需要重寫下面幾個AQS提供的模板方法：

isHeldExclusively()//該執行緒是否正在獨佔資源。只有用到condition才需要去實現它。
tryAcquire(int)//獨佔方式。嘗試獲取資源，成功則返回true，失敗則返回false。
tryRelease(int)//獨佔方式。嘗試釋放資源，成功則返回true，失敗則返回false。
tryAcquireShared(int)//共享方式。嘗試獲取資源。負數表示失敗；0表示成功，但沒有剩餘可用資源；正數表示成功，且有剩餘資源。
tryReleaseShared(int)//共享方式。嘗試釋放資源，成功則返回true，失敗則返回false。

預設情況下，每個方法都丟擲 UnsupportedOperationException。 這些方法的實現必須是內部執行緒安全的，並且通常應該簡短而不是阻塞。AQS類中的其他方法都是final ，所以無法被其他類使用，只有這幾個方法可以被其他類使用。

以ReentrantLock為例，state初始化為0，表示未鎖定狀態。A執行緒lock()時，會呼叫tryAcquire()獨佔該鎖並將state+1。此後，其他執行緒再tryAcquire()時就會失敗，直到A執行緒unlock()到state=0（即釋放鎖）為止，其它執行緒才有機會獲取該鎖。當然，釋放鎖之前，A執行緒自己是可以重複獲取此鎖的（state會累加），這就是可重入的概念。但要注意，獲取多少次就要釋放多麼次，這樣才能保證state是能回到零態的。

再以CountDownLatch以例，任務分為N個子執行緒去執行，state也初始化為N（注意N要與執行緒個數一致）。這N個子執行緒是並行執行的，每個子執行緒執行完後countDown()一次，state會CAS(Compare and Swap)減1。等到所有子執行緒都執行完後(即state=0)，會unpark()主呼叫執行緒，然後主呼叫執行緒就會從await()函式返回，繼續後餘動作。

一般來說，自定義同步器要麼是獨佔方法，要麼是共享方式，他們也只需實現tryAcquire-tryRelease、tryAcquireShared-tryReleaseShared中的一種即可。但AQS也支援自定義同步器同時實現獨佔和共享兩種方式，如ReentrantReadWriteLock。

推薦兩篇 AQS 原理和相關原始碼分析的文章：

5.3 AQS 元件總結

  • Semaphore(訊號量)-允許多個執行緒同時訪問： synchronized 和 ReentrantLock 都是一次只允許一個執行緒訪問某個資源，Semaphore(訊號量)可以指定多個執行緒同時訪問某個資源。
  • CountDownLatch （倒計時器）： CountDownLatch是一個同步工具類，用來協調多個執行緒之間的同步。這個工具通常用來控制執行緒等待，它可以讓某一個執行緒等待直到倒計時結束，再開始執行。
  • CyclicBarrier(迴圈柵欄)： CyclicBarrier 和 CountDownLatch 非常類似，它也可以實現執行緒間的技術等待，但是它的功能比 CountDownLatch 更加複雜和強大。主要應用場景和 CountDownLatch 類似。CyclicBarrier 的字面意思是可迴圈使用（Cyclic）的屏障（Barrier）。它要做的事情是，讓一組執行緒到達一個屏障（也可以叫同步點）時被阻塞，直到最後一個執行緒到達屏障時，屏障才會開門，所有被屏障攔截的執行緒才會繼續幹活。CyclicBarrier預設的構造方法是 CyclicBarrier(int parties)，其引數表示屏障攔截的執行緒數量，每個執行緒呼叫await方法告訴 CyclicBarrier 我已經到達了屏障，然後當前執行緒被阻塞。
     

Reference

相關推薦

多執行緒常用面試題

一 面試中關於 synchronized 關鍵字的 5 連擊 1.1 說一說自己對於 synchronized 關鍵字的瞭解  synchronized關鍵字解決的是多個執行緒之間訪問資源的同步性，synchronized關鍵字可以保證被它修飾的方法或者程式碼塊在任意時刻只能有

Java多執行緒常用面試題(含答案,精心總結整理)

Java併發程式設計問題是面試過程中很容易遇到的問題，提前準備是解決問題的最好辦法，將試題總結起來，時常檢視會有奇效。 現在有T1、T2、T3三個執行緒，你怎樣保證T2在T1執行完後執行，T3在T2執行完後執行？ 這個執行緒問題通常會在第一輪或電話面試階段

Java多執行緒精選面試題

1、多執行緒有什麼用？ 1）發揮多核CPU的優勢 隨著工業的進步，現在的筆記本、桌上型電腦乃至商用的應用伺服器至少也都是雙核的，4核、8核甚至16核的也都不少見，如果是單執行緒的程式，那麼在雙核CPU上就浪費了50%，在4核CPU上就浪費了75%。單核CPU上所謂的"多執行緒"那是假的多

面試題之——多執行緒併發面試題

1) 什麼是執行緒？ 　　執行緒是作業系統能夠進行運算排程的最小單位，它被包含在程序之中，是程序中的實際運作單位。程式設計師可以通過它進行多處理器程式設計，你可以使用多執行緒對運算密集型任務提速。比如，如果一個執行緒完成一個任務要100毫秒，那麼用十個執行緒完成改任務只需10毫秒。Java在語言層面對多執行

多執行緒經典面試題和答案

Java實現執行緒有哪幾種方式？ 1、繼承Thread類實現多執行緒 2、實現Runnable介面方式實現多執行緒 3、使用ExecutorService、Callable、Future實現有返回結果的多執行緒       多執行緒同步有哪幾種方法？

秒殺多執行緒第一篇 多執行緒筆試面試題彙總

    系列前言    本系列是本人蔘加微軟亞洲研究院，騰訊研究院，迅雷面試時整理的，另外也加入一些其它IT公司如百度，阿里巴巴的筆試面試題目，因此具有很強的針對性。系列中不但會詳細講解多執行緒同步互斥的各種“招式”，而且會進一步的講解多執行緒同步互斥的“內功心法”。有了“招

個人珍藏的80道多執行緒併發面試題（1-10答案解析）

前言 個人珍藏的80道Java多執行緒/併發經典面試題，因為篇幅太長，現在先給出1-10的答案解析哈，後面一起完善，並且上傳github哈~ ❝ https://github.com/whx123/JavaHome ❞ 「公眾號：撿田螺的小男孩」 1. synchronized的實現原理以及鎖優化？ sync

個人珍藏的80道多執行緒併發面試題（11-20答案解析）

## 前言 個人珍藏的80道Java多執行緒/併發經典面試題，現在給出11-20的答案解析哈，並且上傳github哈~ > https://github.com/whx123/JavaHome [個人珍藏的80道多執行緒併發面試題（1-10答案解析）](https://juejin.im/post/

多執行緒常用操作方法（sleep、yield、join）

執行緒的命名與取得 執行緒的命名： 通過構造方法在建立執行緒時設定執行緒名稱 直接繼承Thread類： public Thread (String name); Runable或者Callable介面實現多執行緒： public Thread (Run

java之執行緒池面試題

面試官：執行緒池有哪些？分別的作用是什麼？ 常用的執行緒池有： newSingleThreadExecutor newFixedThreadExecutor newCacheThreadExecutor newScheduleThreadExecutor 1、newSingleTh

Java多執行緒常用物件

一、CountDownLatch public class CountDownLatchUtils { private static final int count = 5; public static void main(String[] args) {

java多執行緒常用建立方式

1 繼承Thread類重寫run方法 class Thread111 extends Thread{ @Override public void run() { System.out.println("thread1"); } } public class Thread1 {

java執行緒池 面試題（精簡）

什麼是執行緒池？ 執行緒池是一種多執行緒處理形式，處理過程中將任務提交到執行緒池，任務的執行交由執行緒池來管理。 如果每個請求都建立一個執行緒去處理，那麼伺服器的資源很快就會被耗盡，使用執行緒池可以減少建立和銷燬執行緒的次數，每個工作執行緒都可以被重複利用，可執行多個任務。  

Java面試執行緒相關面試題

1) 什麼是執行緒？ 執行緒是作業系統能夠進行運算排程的最小單位，它被包含在程序之中，是程序中的實際運作單位。程式設計師可以通過它進行多處理器程式設計，你可以使用多執行緒對運算密集型任務提速。比如，如果一個執行緒完成一個任務要100毫秒，那麼用十個執行緒完成改任務只需10毫秒。Java在

多執行緒常用的幾個方法彙總

最近學習併發程式設計遇到不少問題，就順手總結了有關多執行緒的幾個常用的方法sleep()sleep()方法屬於Thread類，主要的作用是讓當前執行緒停止執行，把cpu讓給其他執行緒執行，但不會釋放物件鎖和監控的狀態，到了指定時間後執行緒又會自動恢復執行狀態注意：執行緒睡眠到期自動甦醒，並返回到可執行狀態，不

整理 C# 多執行緒常用的幾個物件和方法

Thread 幾個中要的方法     Sleep(int):靜態方法，暫停當前執行緒指定的毫秒數     Abort():通常使用該方法來終止一個執行緒  ，Thread.ResetAbort() 可以恢復終止的執行緒     Suspend():不是終止未完成的執行緒，它僅

Java併發多執行緒常用包、類和介面

Java.util.concurrent.locks.Lock          Lock介面          ReadWriteLock介面          Condition介面          ReentrantLock Java.util.concurrent

多執行緒——常用操作方法（二）

多執行緒常用操作可以總結成一下七種。 1、取得當前執行緒物件： public static native Thread currentThread();  2、執行緒的命名和取得當前執行緒的名字：public Thread（Runnable terget,String n

多執行緒常用方法統計

currentThread()： currentThread()方法可返回程式碼段正在被那個執行緒呼叫的資訊。 isAlive()： 方法isAlive()的功能是判斷當前的執行緒是否處於活動狀態。 sleep(): 在指定的毫秒數內讓當前“正在執行的執行緒”休眠（暫停執

Java 多執行緒常用操作方法

1.多執行緒常用方法：    currentThread() :  獲取當前執行的執行緒    getName() ： 獲取執行緒名稱    setName() ： 設定執行緒名稱    sleep(long millis) :  是一個靜態方法，使當前執行執行緒進入睡眠狀態