目录
一、Sempaphone
Sempaphone也就是信号量，提供了资源数量的并发访问控制，使用代码很简单。
Semaphore available = new Semaphore(10， true);
available.acquire();
available.release();假设有n个线程来获取资源n>10，那么n个线程中只有10个能获得资源，其他线程都会阻塞，直到有现成释放了资源。有公平和非公平之分。
Semaphore的实现原理和锁的实现原理基本相同。资源总数就是state的初始值，在acquire里对state变量进行CAS减操作，减到0之后线程阻塞；在release里对state变量进行CAS加操作。
二、CountDownLatch
一个主线程需要等待n个Worker线程工作完成之后才退出就能使用CountDownLatch来完成。
实现原理同样是基于AQS，不过没有公平和非公平之分，阻塞全部await的主线程。
1、await实现分析
await方法中调用了acquireSharedInterruptibly(1)
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}只要state不为0，调用await()方法的线程便会被加入AQS的阻塞队列，进入阻塞状态。
2、countDown实现分析
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
// 通过自旋，尝试将state-1
if (tryReleaseShared(arg)) {
// 释放资源锁，交给其他线程去争取
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
// 直到nextc=0, 释放资源锁。
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}调用countDown函数后进行CAS自旋将state-1，当state=0时，一次性唤醒全部阻塞线程。
三、CyclicBarrier
CyclicBarrier是基于ReentrantLock + Condition实现。
/** 同步操作锁 */
private final ReentrantLock lock = new ReentrantLock();
/** 线程拦截器 Condition维护了一个阻塞队列*/
private final Condition trip = lock.newCondition();
/** 每次拦截的线程数 */
private final int parties;
/* 换代前执行的任务 */
private final Runnable barrierCommand;
/** 表示栅栏的当前代 类似代表本局游戏*/
private Generation generation = new Generation();
/** 计数器 */
private int count;
/** 静态内部类Generation */
private static class Generation {
boolean broken = false;
}//构造器1
/** 创建一个新的CyclicBarrier，它将在给定数量的参与方（线程）等待时触发，并在触发屏障时执行给定的屏障操作，由最后一个进入屏障的线程执行 */
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
//构造器2
/** 创建一个新的CyclicBarrier，当给定数量的参与方（线程）在等待它时，它将跳闸，并且在屏障跳闸时不执行预定义的操作 */
public CyclicBarrier(int parties) {
this(parties, null);
}不仅可以传入参与方的总数量，还可以传入一个回调函数。当所有的线程被唤醒时，barrierAction被执行。
1、CyclicBarrier实现原理
//非定时等待
public int await() throws InterruptedException, BrokenBarrierException {
try {
return dowait(false, 0L);
} catch (TimeoutException toe) {
throw new Error(toe); // cannot happen
}
}
//定时等待
public int await(long timeout, TimeUnit unit)throws InterruptedException,
BrokenBarrierException,
TimeoutException {
return dowait(true, unit.toNanos(timeout));
}可以看到，最终两个方法都走【dowait】 方法，只不过参数不同。下面我们重点看看这个方法到底做了哪些事情。
//核心等待方法
private int dowait(boolean timed, long nanos)
throws InterruptedException, BrokenBarrierException,
TimeoutException {
final ReentrantLock lock = this.lock;
lock.lock();//加锁操作
try {
final Generation g = generation;
//检查当前栅栏是否被打翻
if (g.broken)
throw new BrokenBarrierException();
//检查当前线程是否被中断
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
//每次都将计数器的值-1
int index = --count;
//计数器的值减为0，则需要唤醒所有线程并转换到下一代
if (index == 0) { // tripped
boolean ranAction = false;
try {
//唤醒所有线程前先执行指定的任务
final Runnable command = barrierCommand;
if (command != null)
command.run();
ranAction = true;
//唤醒所有线程并转换到下一代
nextGeneration();
return 0;
} finally {
//确保在任务未成功执行时能将所有线程唤醒
if (!ranAction)
breakBarrier();
}
}
//如果计数器不为0 则执行此循环
// loop until tripped, broken, interrupted, or timed out
for (;;) {
try {
//根据传入的参数来觉得是定时等待还是非定时等待
if (!timed)
//如果没有时间限制，则直接等待，直到被唤醒
trip.await();
else if (nanos > 0L)
//如果有时间限制，则等待指定时间
nanos = trip.awaitNanos(nanos);
} catch (InterruptedException ie) {
//若当前线程在等待期间被中断则打翻栅栏唤醒其它线程
if (g == generation && ! g.broken) {
breakBarrier();
throw ie;
} else {
// 若在捕获中断异常前已经完成在栅栏上的等待，则直接调用中断操作
Thread.currentThread().interrupt();
}
}
//如果线程因为打翻栅栏操作而被唤醒则抛出异常
if (g.broken)
throw new BrokenBarrierException();
//如果线程因为换代操作而被唤醒则返回计数器的值
if (g != generation)
return index;
//如果线程因为时间到了而被唤醒则打翻栅栏并抛出异常
if (timed && nanos <= 0L) {
breakBarrier();
throw new TimeoutException();
}
}
} finally {
lock.unlock();//最终解锁
}
}private void nextGeneration() {
trip.signalAll();
count = parties;
generation = new Generation();
}private void breakBarrier() {
generation.broken = true;
count = parties;
trip.signalAll();//唤醒Condition中等待的线程
}1.CyclicBarrier是可以重用的。
2.CyclicBarrier会响应中断，如果有现成收到中断信号，会唤醒所有线程。
3.回调函数只会被最后一个线程执行一次。
四、Exchanger
Exchanger是一个用于线程间数据交换的同步点。它允许两个线程在一个点上交换彼此的数据。每个线程在调用exchange方法时提供一个对象，然后等待另一个线程到达该点进行交换。一旦两个线程都到达交换点，它们就可以安全地交换数据并继续执行。
import java.util.concurrent.Exchanger;
public class ExchangerExample {
public static void main(String[] args) {
// 创建一个Exchanger对象
Exchanger<String> exchanger = new Exchanger<>();
// 创建一个线程，它将使用"Hello"与另一个线程交换数据
Thread producer = new Thread(() -> {
try {
String producedData = "Hello";
String consumerData = exchanger.exchange(producedData);
System.out.println("生产者线程交换后得到的数据: " + consumerData);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "生产者线程");
// 创建一个线程，它将使用"World"与另一个线程交换数据
Thread consumer = new Thread(() -> {
try {
String consumerData = "World";
String producedData = exchanger.exchange(consumerData);
System.out.println("消费者线程交换后得到的数据: " + producedData);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}, "消费者线程");
// 启动线程
producer.start();
consumer.start();
}
}
1、实现原理
Exchanger的核心机制和Lock一样，也是CAS+park/unpark。
// 用于左移Node数组下标，以便得出数组在内存中偏移量来获取数据，避免伪共享
private static final int ASHIFT = 7;
// Node数组最大下标
private static final int MMASK = 0xff;
// 用于递增bound，每次递增一个SEQ
private static final int SEQ = MMASK + 1;
// CPU核心数
private static final int NCPU = Runtime.getRuntime().availableProcessors();
// 当前数组最大下标
static final int FULL = (NCPU >= (MMASK << 1)) ? MMASK : NCPU >>> 1;
// 自旋次数，CPU核心为1时自旋会被禁用
private static final int SPINS = 1 << 10;
// 用于exchange方法中参数为null时传递给其它线程的对象
private static final Object NULL_ITEM = new Object();
// 用于超时传递的对象
private static final Object TIMED_OUT = new Object();
// 节点用于保持需要交换的数据
@sun.misc.Contended static final class Node {
int index; // arana数组下标，多槽位时使用
int bound; // 上一次记录的bound
int collides; // CAS失败次数
int hash; // 用于自旋的伪随机数
Object item; // 当前线程需要交换的数据
volatile Object match; // 匹配线程交换的数据
volatile Thread parked; // 记录当前挂起的线程
}
// 用户记录线程状态的内部类
static final class Participant extends ThreadLocal<Node> {
public Node initialValue() { return new Node(); }
}
// 记录线程状态
private final Participant participant;
// 多槽位数据交换使用
private volatile Node[] arena;
// 用于交换数据的槽位
private volatile Node slot;
/**
* The index of the largest valid arena position, OR'ed with SEQ
* number in high bits, incremented on each update. The initial
* update from 0 to SEQ is used to ensure that the arena array is
* constructed only once.
*/
private volatile int bound;
每个线程在调用exchange函数交换数据的时候，会先创建一个Node对象，这个Node对象包含了要交换的数据，线程本身，对方所要交换的数据，初始为NULL。为优化性能进行了缓存行填充。
Slot用于交换数据，保存其中一个线程的数据，当第二个线程到时，进行数据交换。一个Slot只能支持2个线程之间交换数据，要实现多个线程并行的交换诗句，需要多个Slot，因此在Exchanger里面定义了Slot数组。
2、情况分析
1、当一个线程调用exchanger准备和其他线程交换数据的时候，无外乎两种情况。一种是没有其他线程要交换数据，自己只能自旋或者阻塞，等待；另一种是恰好有其他线程在Slot里面等着，那么就和对方交换。
2、由于Slot不止一个，而是多个。如果运气好根据自己的thread id找到对应的Slot，里面恰好有其他线程在等待，就和对方交换。
3、如果运气不好，Slot是空的，不代表其他的Slot没有现成在等待。因此此时的Slot的index=0自己阻塞在那。否则便利全部的Slot，看其他的Slot里面是否有现成在等待。没有的话再在index=0处阻塞等待。
304
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
