![](http://img.blog.itpub.net/blog/2020/03/30/1bb567cf40a5bc69.png?x-oss-process=style/bb)

# 一、Exchanger 交換器（兩執行緒間的通訊）

**使用場景：**用於 有且僅有兩個執行緒 間的 資料傳輸，就就是執行緒間的 通訊 。它是 生產者/消費者 d的 wait() / notify() 的最佳替代工具。 核心原理：方法 exchange()阻塞特性：此方法被呼叫後等待其他執行緒來取資料，如果沒有其他執行緒取得資料，則一直 阻塞。

示例：交替列印奇偶數：
```
public class Print {
    public static void main(String[] args) {
	// 交換器
	Exchanger<integer> exchanger = new Exchanger<>();
	// 起始列印數值
	Integer startNumber = 1;
	// 終止的數值
	Integer endNumber= 100;
	// 執行緒1
	Thread t1 = new Thread(new Thread1(exchanger, startNumber, endNumber));
	Thread t2 = new Thread(new Thread2(exchanger, startNumber, endNumber));
	// 設定執行緒名稱
	t1.setName("thread-no-1");
	t2.setName("thread-no-2");
	// 啟動執行緒
	t1.start();
	t2.start();
}
}
/**
 * 列印奇數的執行緒
 */
class Thread1 implements Runnable {
private Exchanger<integer> exchanger;
/** 被列印的數 */
private Integer number;
private final Integer endNumber;
public Thread1(Exchanger<integer> exchanger, Integer startNumber, Integer endNumber) {
	this.exchanger = exchanger;
	this.number = startNumber;
	this.endNumber = endNumber;
}
@Override
    public void run() {
	while (number <= endNumber) {
		if (number % 2 == 1) {
			System.out.println("執行緒：" + Thread.currentThread().getName() + " : " + number);
		}
		try {
			exchanger.exchange(number++);
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
}
/**
 * 列印偶數的執行緒
 */
class Thread2 implements Runnable {
private Exchanger<integer> exchanger;
/** 被列印的數 */
private Integer number;
private final Integer endNumber;
public Thread2(Exchanger<integer> exchanger, Integer startNumber, Integer endNumber) {
	this.exchanger = exchanger;
	this.number = startNumber;
	this.endNumber = endNumber;
}
@Override
    public void run() {
	while (number <= endNumber) {
		if (number % 2 == 0) {
			System.out.println("執行緒：" + Thread.currentThread().getName() + " : " + number);
		}
		try {
			exchanger.exchange(number++);
		}
		catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}
}
```

# 二、Semaphore 訊號燈

核心原理： 透過發放設定最大 許可數，來限制執行緒的併發數。 預設是 非公平鎖，效率高。
```
public Semaphore(int permits) {
	sync = new NonfairSync(permits);
}
Semaphore semaphore = new Semaphore(5);
try {
	semaphore.acquire();
	// 獲取許可
	// 邏輯
}
catch (InterruptedException e) {
	e.printStackTrace();
}
finally {
	semaphore.release();
	// 釋放許可
}
```
# 三、CountDownLatch 倒數計時閂（鎖）

核心原理：執行緒以 組團 的方式進行任務。 count 作為 stat 狀態。await() 方式將 阻塞當前執行緒，直到 count 為 0。
```
CountDownLatch countDownLatch = new CountDownLatch(5);
countDownLatch.countDown();
// count - 1
// 預處理
try {
	countDownLatch.await();
	// 阻塞當前執行緒
	// 大家一起處理的時候，我才處理
}
catch (InterruptedException e) {
	e.printStackTrace();
}
```
Sync同步器
```
private static final class Sync extends AbstractQueuedSynchronizer {
	private static final long serialVersionUID = 4982264981922014374L;
	Sync(int count) {
		setState(count);
	}
	int getCount() {
		return getState();
	}
	protected int tryAcquireShared(int acquires) {
		return (getState() == 0) ? 1 : -1;
	}
	protected Boolean tryReleaseShared(int releases) {
		// 遞減 count; 轉換為零時發出訊號
		for (;;) {
			int c = getState();
			if (c == 0)
			                return false;
			int nextc = c-1;
			if (compareAndSetState(c, nextc))
			                return nextc == 0;
		}
	}
}
```
# 四、CyclicBarrier 迴圈柵欄（迴圈鎖）

核心原理： 基於 ReentrantLock 和 Condition。 CyclicBarrier 不僅具有 CountDownLatch 的功能，還有實現屏障等待的功能，也就是階段性同步。

**CyclicBarrier與CountDownLatch比較**

- CountDownLatch:一個執行緒(或者多個)，等待另外N個執行緒完成某個事情之後才能執行；CyclicBarrier:N個執行緒相互等待，任何一個執行緒完成之前，所有的執行緒都必須等待。
- CountDownLatch:一次性的；CyclicBarrier:可以重複使用。
- CountDownLatch基於AQS；CyclicBarrier基於鎖和Condition。本質上都是依賴於volatile和CAS實現的。</integer></integer></integer></integer></integer>

深入理解Java多執行緒與併發框（第⑩篇）——併發輔助工具類（很好的玩的工具類）

相關文章