本系列研究總結高併發下的幾種同步鎖的使用以及之間的區別,分別是:ReentrantLock、CountDownLatch、CyclicBarrier、Phaser、ReadWriteLock、StampedLock、Semaphore、Exchanger、LockSupport。由於部落格園對部落格字數的要求限制,會分為三個篇幅:
高併發之ReentrantLock、CountDownLatch、CyclicBarrier
高併發之Phaser、ReadWriteLock、StampedLock
高併發之Semaphore、Exchanger、LockSupport
Semaphore
訊號量(Semaphore)，有時被稱為訊號燈，是在多執行緒環境下使用的一種設施, 它負責協調各個執行緒, 以保證它們能夠正確、合理的使用公共資源。Semaphore分為單值和多值兩種，前者只能被一個執行緒獲得，後者可以被若干個執行緒獲得。
情境引入
以一個停車場是運作為例。為了簡單起見，假設停車場只有三個車位，一開始三個車位都是空的。這是如果同時來了五輛車，看門人允許其中三輛不受阻礙的進入，然後放下車攔，剩下的車則必須在入口等待，此後來的車也都不得不在入口處等待。這時，有一輛車離開停車場，看門人得知後，開啟車攔，放入一輛，如果又離開兩輛，則又可以放入兩輛，如此往復。
在這個停車場系統中，車位是公共資源，每輛車好比一個執行緒，看門人起的就是訊號量的作用。更進一步，訊號量的特性如下：訊號量是一個非負整數（車位數），所有通過它的執行緒（車輛）都會將該整數減一（通過它當然是為了使用資源），當該整數值為零時，所有試圖通過它的執行緒都將處於等待狀態。在訊號量上我們定義兩種操作： Wait（等待） 和 Release（釋放）。 當一個執行緒呼叫Wait等待）操作時，它要麼通過然後將訊號量減一，要麼一自等下去，直到訊號量大於一或超時。Release（釋放）實際上是在訊號量上執行加操作，對應於車輛離開停車場，該操作之所以叫做“釋放”是應為加操作實際上是釋放了由訊號量守護的資源。
使用程式碼示例
public class TestSemaphore {
public static void main(String[] args) {
//Semaphore s = new Semaphore(2);
Semaphore s = new Semaphore(2, true);
//允許一個執行緒同時執行
//Semaphore s = new Semaphore(1);
new Thread(()->{
try {
s.acquire();
System.out.println("T1 running...");
Thread.sleep(200);
System.out.println("T1 running...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
s.release();
}
}).start();
new Thread(()->{
try {
s.acquire();
System.out.println("T2 running...");
Thread.sleep(200);
System.out.println("T2 running...");
s.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
}
}
Exchanger
Exchanger，它允許在併發任務之間交換資料。具體來說，Exchanger類允許在兩個執行緒之間定義同步點。當兩個執行緒都到達同步點時，他們交換資料結構，因此第一個執行緒的資料結構進入到第二個執行緒中，第二個執行緒的資料結構進入到第一個執行緒中。
Exchanger是在兩個任務之間交換物件的柵欄，當這些任務進入柵欄時，它們各自擁有一個物件。當他們離開時，它們都擁有之前由物件持有的物件。它典型的應用場景是：一個任務在建立物件，這些物件的生產代價很高昂，而另一個任務在消費這些物件。通過這種方式，可以有更多的物件在被建立的同時被消費。
應用示例
Exchange實現較為複雜，我們先看其怎麼使用，然後再來分析其原始碼。現在我們用Exchange來模擬生產-消費者問題：
public class ExchangerTest {
static class Producer implements Runnable{
//生產者、消費者交換的資料結構
private List<String> buffer;
//步生產者和消費者的交換物件
private Exchanger<List<String>> exchanger;
Producer(List<String> buffer,Exchanger<List<String>> exchanger){
this.buffer = buffer;
this.exchanger = exchanger;
}
@Override
public void run() {
for(int i = 1 ; i < 5 ; i++){
System.out.println("生產者第" + i + "次提供");
for(int j = 1 ; j <= 3 ; j++){
System.out.println("生產者裝入" + i + "--" + j);
buffer.add("buffer：" + i + "--" + j);
}
System.out.println("生產者裝滿，等待與消費者交換...");
try {
exchanger.exchange(buffer);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
static class Consumer implements Runnable {
private List<String> buffer;
private final Exchanger<List<String>> exchanger;
public Consumer(List<String> buffer, Exchanger<List<String>> exchanger) {
this.buffer = buffer;
this.exchanger = exchanger;
}
@Override
public void run() {
for (int i = 1; i < 5; i++) {
//呼叫exchange()與消費者進行資料交換
try {
buffer = exchanger.exchange(buffer);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("消費者第" + i + "次提取");
for (int j = 1; j <= 3 ; j++) {
System.out.println("消費者 : " + buffer.get(0));
buffer.remove(0);
}
}
}
}
public static void main(String[] args){
List<String> buffer1 = new ArrayList<String>();
List<String> buffer2 = new ArrayList<String>();
Exchanger<List<String>> exchanger = new Exchanger<List<String>>();
Thread producerThread = new Thread(new Producer(buffer1,exchanger));
Thread consumerThread = new Thread(new Consumer(buffer2,exchanger));
producerThread.start();
consumerThread.start();
}
}
列印結果
生產者第1次提供
生產者裝入1--1
生產者裝入1--2
生產者裝入1--3
生產者裝滿，等待與消費者交換...
生產者第2次提供
生產者裝入2--1
生產者裝入2--2
生產者裝入2--3
生產者裝滿，等待與消費者交換...
消費者第1次提取
消費者 : buffer：1--1
消費者 : buffer：1--2
消費者 : buffer：1--3
消費者第2次提取
......
首先生產者Producer、消費者Consumer首先都建立一個緩衝列表，通過Exchanger來同步交換資料。消費中通過呼叫Exchanger與生產者進行同步來獲取資料，而生產者則通過for迴圈向快取佇列儲存資料並使用exchanger物件消費者同步。到消費者從exchanger哪裡得到資料後，他的緩衝列表中有3個資料，而生產者得到的則是一個空的列表。上面的例子充分展示了消費者-生產者是如何利用Exchanger來完成資料交換的。
在Exchanger中，如果一個執行緒已經到達了exchanger節點時，對於它的夥伴節點的情況有三種：
- 如果它的夥伴節點在該執行緒到達之前已經呼叫了exchanger方法，則它會喚醒它的夥伴然後進行資料交換，得到各自資料返回。
- 如果它的夥伴節點還沒有到達交換點，則該執行緒將會被掛起，等待它的夥伴節點到達被喚醒，完成資料交換。
- 如果當前執行緒被中斷了則丟擲異常，或者等待超時了，則丟擲超時異常。
實現分析
Exchanger演算法的核心是通過一個可交換資料的slot，以及一個可以帶有資料item的參與者。原始碼中的描述如下：
for (;;) {
if (slot is empty) { // offer
place item in a Node;
if (can CAS slot from empty to node) {
wait for release;
return matching item in node;
}
}
else if (can CAS slot from node to empty) { // release
get the item in node;
set matching item in node;
release waiting thread;
}
// else retry on CAS failure
}
Exchanger中定義瞭如下幾個重要的成員變數：
private final Participant participant;
private volatile Node[] arena;
private volatile Node slot;
participant的作用是為每個執行緒保留唯一的一個Node節點。
slot為單個槽，arena為陣列槽。他們都是Node型別。在這裡可能會感覺到疑惑，slot作為Exchanger交換資料的場景，應該只需要一個就可以了啊？為何還多了一個Participant 和陣列型別的arena呢？一個slot交換場所原則上來說應該是可以的，但實際情況卻不是如此，多個參與者使用同一個交換場所時，會存在嚴重伸縮性問題。既然單個交換場所存在問題，那麼我們就安排多個，也就是陣列arena。通過陣列arena來安排不同的執行緒使用不同的slot來降低競爭問題，並且可以保證最終一定會成對交換資料。但是Exchanger不是一來就會生成arena陣列來降低競爭，只有當產生競爭是才會生成arena陣列。那麼怎麼將Node與當前執行緒繫結呢？Participant ，Participant 的作用就是為每個執行緒保留唯一的一個Node節點，它繼承ThreadLocal，同時在Node節點中記錄在arena中的下標index。
Node定義如下：
@sun.misc.Contended static final class Node {
int index; // Arena index
int bound; // Last recorded value of Exchanger.bound
int collides; // Number of CAS failures at current bound
int hash; // Pseudo-random for spins
Object item; // This thread's current item
volatile Object match; // Item provided by releasing thread
volatile Thread parked; // Set to this thread when parked, else null
}
- index：arena的下標；
- bound：上一次記錄的Exchanger.bound；
- collides：在當前bound下CAS失敗的次數；
- hash：偽隨機數，用於自旋；
- item：這個執行緒的當前項，也就是需要交換的資料；
- match：做releasing操作的執行緒傳遞的項；
- parked：掛起時設定執行緒值，其他情況下為null；
在Node定義中有兩個變數值得思考：bound以及collides。前面提到了陣列area是為了避免競爭而產生的，如果系統不存在競爭問題，那麼完全沒有必要開闢一個高效的arena來徒增系統的複雜性。首先通過單個slot的exchanger來交換資料，當探測到競爭時將安排不同的位置的slot來儲存執行緒Node，並且可以確保沒有slot會在同一個快取行上。如何來判斷會有競爭呢？CAS替換slot失敗，如果失敗，則通過記錄衝突次數來擴充套件arena的尺寸，我們在記錄衝突的過程中會跟蹤“bound”的值，以及會重新計算衝突次數在bound的值被改變時。這裡闡述可能有點兒模糊，不著急，我們先有這個概念，後面在arenaExchange中再次做詳細闡述,我們直接看exchange()方法。
exchange(V x)
exchange(V x)：等待另一個執行緒到達此交換點（除非當前執行緒被中斷），然後將給定的物件傳送給該執行緒，並接收該執行緒的物件。方法定義如下：
public V exchange(V x) throws InterruptedException {
Object v;
Object item = (x == null) ? NULL_ITEM : x; // translate null args
if ((arena != null ||
(v = slotExchange(item, false, 0L)) == null) &&
((Thread.interrupted() || // disambiguates null return
(v = arenaExchange(item, false, 0L)) == null)))
throw new InterruptedException();
return (v == NULL_ITEM) ? null : (V)v;
}
這個方法比較好理解：arena為陣列槽，如果為null，則執行slotExchange()方法，否則判斷執行緒是否中斷，如果中斷值丟擲InterruptedException異常，沒有中斷則執行arenaExchange()方法。整套邏輯就是：如果slotExchange(Object item, boolean timed, long ns)方法執行失敗了就執行arenaExchange(Object item, boolean timed, long ns)方法，最後返回結果V。
NULL_ITEM 為一個空節點，其實就是一個Object物件而已，slotExchange()為單個slot交換。
slotExchange(Object item, boolean timed, long ns)
private final Object slotExchange(Object item, boolean timed, long ns) {
// 獲取當前執行緒的節點 p
Node p = participant.get();
// 當前執行緒
Thread t = Thread.currentThread();
// 執行緒中斷，直接返回
if (t.isInterrupted())
return null;
// 自旋
for (Node q;;) {
//slot != null
if ((q = slot) != null) {
//嘗試CAS替換
if (U.compareAndSwapObject(this, SLOT, q, null)) {
Object v = q.item; // 當前執行緒的項，也就是交換的資料
q.match = item; // 做releasing操作的執行緒傳遞的項
Thread w = q.parked; // 掛起時設定執行緒值
// 掛起執行緒不為null，執行緒掛起
if (w != null)
U.unpark(w);
return v;
}
//如果失敗了，則建立arena
//bound 則是上次Exchanger.bound
if (NCPU > 1 && bound == 0 &&
U.compareAndSwapInt(this, BOUND, 0, SEQ))
arena = new Node[(FULL + 2) << ASHIFT];
}
//如果arena != null，直接返回，進入arenaExchange邏輯處理
else if (arena != null)
return null;
else {
p.item = item;
if (U.compareAndSwapObject(this, SLOT, null, p))
break;
p.item = null;
}
}
/*
* 等待 release
* 進入spin+block模式
*/
int h = p.hash;
long end = timed ? System.nanoTime() + ns : 0L;
int spins = (NCPU > 1) ? SPINS : 1;
Object v;
while ((v = p.match) == null) {
if (spins > 0) {
h ^= h << 1; h ^= h >>> 3; h ^= h << 10;
if (h == 0)
h = SPINS | (int)t.getId();
else if (h < 0 && (--spins & ((SPINS >>> 1) - 1)) == 0)
Thread.yield();
}
else if (slot != p)
spins = SPINS;
else if (!t.isInterrupted() && arena == null &&
(!timed || (ns = end - System.nanoTime()) > 0L)) {
U.putObject(t, BLOCKER, this);
p.parked = t;
if (slot == p)
U.park(false, ns);
p.parked = null;
U.putObject(t, BLOCKER, null);
}
else if (U.compareAndSwapObject(this, SLOT, p, null)) {
v = timed && ns <= 0L && !t.isInterrupted() ? TIMED_OUT : null;
break;
}
}
U.putOrderedObject(p, MATCH, null);
p.item = null;
p.hash = h;
return v;
}
程式首先通過participant獲取當前執行緒節點Node。檢測是否中斷，如果中斷return null，等待後續丟擲InterruptedException異常。
如果slot不為null，則進行slot消除，成功直接返回資料V，否則失敗，則建立arena消除陣列。
如果slot為null，但arena不為null，則返回null，進入arenaExchange邏輯。
如果slot為null，且arena也為null，則嘗試佔領該slot，失敗重試，成功則跳出迴圈進入spin+block（自旋+阻塞）模式。
在自旋+阻塞模式中，首先取得結束時間和自旋次數。如果match(做releasing操作的執行緒傳遞的項)為null，其首先嚐試spins+隨機次自旋（改自旋使用當前節點中的hash，並改變之）和退讓。當自旋數為0後，假如slot發生了改變（slot != p）則重置自旋數並重試。否則假如：當前未中斷&arena為null&（當前不是限時版本或者限時版本+當前時間未結束）：阻塞或者限時阻塞。假如：當前中斷或者arena不為null或者當前為限時版本+時間已經結束：不限時版本：置v為null；限時版本：如果時間結束以及未中斷則TIMED_OUT；否則給出null（原因是探測到arena非空或者當前執行緒中斷）。
match不為空時跳出迴圈。
整個slotExchange清晰明瞭。
arenaExchange
arenaExchange(Object item, boolean timed, long ns)
private final Object arenaExchange(Object item, boolean timed, long ns) {
Node[] a = arena;
Node p = participant.get();
for (int i = p.index;;) { // access slot at i
int b, m, c; long j; // j is raw array offset
Node q = (Node)U.getObjectVolatile(a, j = (i << ASHIFT) + ABASE);
if (q != null && U.compareAndSwapObject(a, j, q, null)) {
Object v = q.item; // release
q.match = item;
Thread w = q.parked;
if (w != null)
U.unpark(w);
return v;
}
else if (i <= (m = (b = bound) & MMASK) && q == null) {
p.item = item; // offer
if (U.compareAndSwapObject(a, j, null, p)) {
long end = (timed && m == 0) ? System.nanoTime() + ns : 0L;
Thread t = Thread.currentThread(); // wait
for (int h = p.hash, spins = SPINS;;) {
Object v = p.match;
if (v != null) {
U.putOrderedObject(p, MATCH, null);
p.item = null; // clear for next use
p.hash = h;
return v;
}
else if (spins > 0) {
h ^= h << 1; h ^= h >>> 3; h ^= h << 10; // xorshift
if (h == 0) // initialize hash
h = SPINS | (int)t.getId();
else if (h < 0 && // approx 50% true
(--spins & ((SPINS >>> 1) - 1)) == 0)
Thread.yield(); // two yields per wait
}
else if (U.getObjectVolatile(a, j) != p)
spins = SPINS; // releaser hasn't set match yet
else if (!t.isInterrupted() && m == 0 &&
(!timed ||
(ns = end - System.nanoTime()) > 0L)) {
U.putObject(t, BLOCKER, this); // emulate LockSupport
p.parked = t; // minimize window
if (U.getObjectVolatile(a, j) == p)
U.park(false, ns);
p.parked = null;
U.putObject(t, BLOCKER, null);
}
else if (U.getObjectVolatile(a, j) == p &&
U.compareAndSwapObject(a, j, p, null)) {
if (m != 0) // try to shrink
U.compareAndSwapInt(this, BOUND, b, b + SEQ - 1);
p.item = null;
p.hash = h;
i = p.index >>>= 1; // descend
if (Thread.interrupted())
return null;
if (timed && m == 0 && ns <= 0L)
return TIMED_OUT;
break; // expired; restart
}
}
}
else
p.item = null; // clear offer
}
else {
if (p.bound != b) { // stale; reset
p.bound = b;
p.collides = 0;
i = (i != m || m == 0) ? m : m - 1;
}
else if ((c = p.collides) < m || m == FULL ||
!U.compareAndSwapInt(this, BOUND, b, b + SEQ + 1)) {
p.collides = c + 1;
i = (i == 0) ? m : i - 1; // cyclically traverse
}
else
i = m + 1; // grow
p.index = i;
}
}
}
首先通過participant取得當前節點Node，然後根據當前節點Node的index去取arena中相對應的節點node。前面提到過arena可以確保不同的slot在arena中是不會相沖突的，那麼是怎麼保證的呢？我們先看arena的建立：
arena = new Node[(FULL + 2) << ASHIFT];
這個arena到底有多大呢？我們先看FULL 和ASHIFT的定義：
static final int FULL = (NCPU >= (MMASK << 1)) ? MMASK : NCPU >>> 1;
private static final int ASHIFT = 7;
private static final int NCPU = Runtime.getRuntime().availableProcessors();
private static final int MMASK = 0xff; // 255
假如我的機器NCPU = 8 ，則得到的是768大小的arena陣列。然後通過以下程式碼取得在arena中的節點：
Node q = (Node)U.getObjectVolatile(a, j = (i << ASHIFT) + ABASE);
仍然是通過右移ASHIFT位來取得Node的，ABASE定義如下：
Class<?> ak = Node[].class;
ABASE = U.arrayBaseOffset(ak) + (1 << ASHIFT);
U.arrayBaseOffset獲取物件頭長度，陣列元素的大小可以通過unsafe.arrayIndexScale(T[].class) 方法獲取到。這也就是說要訪問型別為T的第N個元素的話，你的偏移量offset應該是arrayOffset+N*arrayScale。也就是說BASE = arrayOffset+ 128 。其次我們再看Node節點的定義
@sun.misc.Contended static final class Node{
....
}
在Java 8 中我們是可以利用sun.misc.Contended來規避偽共享的。所以說通過 << ASHIFT方式加上sun.misc.Contended，所以使得任意兩個可用Node不會再同一個快取行中。
LockSupport
LockSupport是一個執行緒阻塞工具類，所有的方法都是靜態方法，可以讓執行緒在任意位置阻塞，當然阻塞之後肯定得有喚醒的方法。
常用方法
接下面我來看看LockSupport有哪些常用的方法。主要有兩類方法：park和unpark。
public static void park(Object blocker); // 暫停當前執行緒
public static void parkNanos(Object blocker, long nanos); // 暫停當前執行緒，不過有超時時間的限制
public static void parkUntil(Object blocker, long deadline); // 暫停當前執行緒，直到某個時間
public static void park(); // 無期限暫停當前執行緒
public static void parkNanos(long nanos); // 暫停當前執行緒，不過有超時時間的限制
public static void parkUntil(long deadline); // 暫停當前執行緒，直到某個時間
public static void unpark(Thread thread); // 恢復當前執行緒
public static Object getBlocker(Thread t);
park英文意思為停車。我們如果把Thread看成一輛車的話，park就是讓車停下，unpark就是讓車啟動然後跑起來。
寫一個例子來看看這個工具類怎麼用
public class LockSupportDemo {
public static Object u = new Object();
static ChangeObjectThread t1 = new ChangeObjectThread("t1");
static ChangeObjectThread t2 = new ChangeObjectThread("t2");
public static class ChangeObjectThread extends Thread {
public ChangeObjectThread(String name) {
super(name);
}
@Override public void run() {
synchronized (u) {
System.out.println("in " + getName());
LockSupport.park();
if (Thread.currentThread().isInterrupted()) {
System.out.println("被中斷了");
}
System.out.println("繼續執行");
}
}
}
public static void main(String[] args) throws InterruptedException {
t1.start();
Thread.sleep(1000L);
t2.start();
Thread.sleep(3000L);
t1.interrupt();
LockSupport.unpark(t2);
t1.join();
t2.join();
}
}
執行的結果如下：
in t1
被中斷了
繼續執行
in t2
繼續執行
這兒park和unpark其實實現了wait和notify的功能，不過還是有一些差別的。
park不需要獲取某個物件的鎖- 因為中斷的時候
park不會丟擲InterruptedException異常，所以需要在park之後自行判斷中斷狀態，然後做額外的處理
我們再來看看Object blocker，這是個什麼東西呢？這其實就是方便線上程dump的時候看到具體的阻塞物件的資訊。
"t1" #10 prio=5 os_prio=31 tid=0x00007f95030cc800 nid=0x4e03 waiting on condition [0x00007000011c9000]
java.lang.Thread.State: WAITING (parking)
at sun.misc.Unsafe.park(Native Method)
at java.util.concurrent.locks.LockSupport.park(LockSupport.java:304)
// `下面的這個資訊`
at com.wtuoblist.beyond.concurrent.demo.chapter3.LockSupportDemo$ChangeObjectThread.run(LockSupportDemo.java:23) //
- locked <0x0000000795830950> (a java.lang.Object)
相對於執行緒的stop和resume，park和unpark的先後順序並不是那麼嚴格。stop和resume如果順序反了，會出現死鎖現象。而park和unpark卻不會。這又是為什麼呢？還是看一個例子
public class LockSupportDemo {
public static Object u = new Object();
static ChangeObjectThread t1 = new ChangeObjectThread("t1");
public static class ChangeObjectThread extends Thread {
public ChangeObjectThread(String name) {
super(name);
}
@Override public void run() {
synchronized (u) {
System.out.println("in " + getName());
try {
Thread.sleep(1000L);
} catch (InterruptedException e) {
e.printStackTrace();
}
LockSupport.park();
if (Thread.currentThread().isInterrupted()) {
System.out.println("被中斷了");
}
System.out.println("繼續執行");
}
}
}
public static void main(String[] args) {
t1.start();
LockSupport.unpark(t1);
System.out.println("unpark invoked");
}
}
t1內部有休眠1s的操作，所以unpark肯定先於park的呼叫，但是t1最終仍然可以完結。這是因為park和unpark會對每個執行緒維持一個許可（boolean值）
- unpark呼叫時，如果當前執行緒還未進入park，則許可為true
- park呼叫時，判斷許可是否為true，如果是true，則繼續往下執行；如果是false，則等待，直到許可為true