記事ディレクトリ
序文
JUC は、ロック、セマフォ、カウンタ、イベント ループ、スレッド プール、同時コレクションなど、一般的に使用されるいくつかの同時実行ツールを提供する Java 同時プログラミング ツール ライブラリです。これらのツールは、開発者が同時プログラミングの複雑さを簡素化し、プログラムの効率と信頼性を向上させるのに役立ちます。
カウントダウンラッチ
カウントダウンラッチアプリケーション
CountDownLatch 自体は、実行前に 1 つ以上のスレッドの完了を待機できるカウンターのようなもので、AQS に基づいて実装されています。
public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
CountDownLatch countDownLatch = new CountDownLatch(3);
new Thread(() -> {
System.out.println("111");
countDownLatch.countDown();
}).start();
new Thread(() -> {
System.out.println("222");
countDownLatch.countDown();
}).start();
new Thread(() -> {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("333");
countDownLatch.countDown();
}).start();
// 主线会阻塞在这个位置，直到CountDownLatch的state变为0
countDownLatch.await();
System.out.println("main");
}
CountDownLatch コアのソース コード
// CountDownLatch 的有参构造
public CountDownLatch(int count) {
// 健壮性校验
if (count < 0) throw new IllegalArgumentException("count < 0");
// 构建Sync给AQS的state赋值
this.sync = new Sync(count);
}
countDown メソッドは基本的に、AQS の共有ロック解放操作を呼び出します。
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
// 唤醒在AQS队列中排队的线程。
doReleaseShared();
return true;
}
return false;
}
// countDownLatch实现的业务
protected boolean tryReleaseShared(int releases) {
for (;;) {
int c = getState();
if (c == 0)
return false;
// state - 1
int nextc = c-1;
// 用CAS赋值
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
// 如果CountDownLatch中的state已经为0了，那么再次执行countDown跟没执行一样。
// 而且只要state变为0，await就不会阻塞线程。
すべての関数は AQS によって提供され、tryReleaseShared で実装する必要があるクラスのみを独自に記述する必要があります。
await メソッドは、AQS が提供するメソッドを呼び出して共有ロックを取得し、中断を許可します。
// await方法
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
// AQS获取共享锁并且允许中断的方法
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
// countDownLatch操作
if (tryAcquireShared(arg) < 0)
// 如果返回的是-1，代表state肯定大于0
doAcquireSharedInterruptibly(arg);
}
// CountDownLatch实现的tryAcquireShared
protected int tryAcquireShared(int acquires) {
// state为0，返回1,。否则返回-1
return (getState() == 0) ? 1 : -1;
}
// 让当前线程进到AQS队列，排队去
private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {
// 将当前线程封装为Node，并且添加到AQS的队列中
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
// 再次走上面的tryAcquireShared，如果返回的是的1，代表state为0
int r = tryAcquireShared(arg);
if (r >= 0) {
// 会将当前线程和后面所有排队的线程都唤醒。
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
セマフォ
セマフォアプリケーション
セマフォは通常、フロー制御に使用されます。たとえば、複数のスレッドからアクセスできるパブリック リソースがある場合、それを制限するためのセマフォとして使用できます。スレッドが接続オブジェクトを取得するたびに、セマフォに -1 が追加され、スレッドがリソースを返すときにセマフォに +1 が追加されます。スレッドがリソースを取得するときに、セマフォ内のリソースの数が 0 であることが判明した場合、スレッドはブロックされます。
public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
// 声明信号量
Semaphore semaphore = new Semaphore(1);
// 能否去拿资源
semaphore.acquire();
// 拿资源处理业务
System.out.println("main");
// 归还资源
semaphore.release();
}
セマフォコアのソースコード
Semaphore には、公平と不公平の 2 つのリソース獲得競争方法があります。
//
public Semaphore(int permits, boolean fair) {
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}
// 设置资源个数，State其实就是信号量的资源个数
Sync(int permits) {
setState(permits);
}
acquire を呼び出してリソースを取得する場合も、AQS が提供する共有ロックを取得する方法に基づきます。
解放とは、状態 + 1 を追加してリソースを返すことを意味します。
// 两个一起 阿巴阿巴
public void release() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
// 唤醒在AQS中排队的Node，去竞争资源
doReleaseShared();
return true;
}
return false;
}
// 信号量实现的归还资源
protected final boolean tryReleaseShared(int releases) {
for (;;) {
// 拿state
int current = getState();
// state + 1
int next = current + releases;
// 资源最大值，再+1，变为负数
if (next < current)
throw new Error("Maximum permit count exceeded");
// CAS 改一手
if (compareAndSetState(current, next))
return true;
}
}
共有ロックがリソースを解放した後、先頭ノードが 0 の場合、本当に後続ノードが存在しないことは確認できません。ヘッド ノードが 0 の場合は、ヘッド ノードのステータスを -3 に変更する必要があります。最新のロック リソースを取得したスレッドが後続ノードが存在するかどうかを確認し、それが共有ロックであるかどうかを確認したら、キューに登録されているスレッドをウェイクアップします。
サイクリックバリア
サイクリックバリアアプリケーション
CyclicBarrier は一般にバリアと呼ばれ、CountDownLatch と非常によく似ています。CountDownLatch は動作中に 1 回だけ使用できます。つまり、状態が 0 になった後は再度使用できません。CyclicBarrier は再利用でき、そのカウンターはリセットして再度処理できます。また、カウント処理中に問題が発生した後は、現在の CyclicBarrier をリセットして、操作を再度開始できます。
public static void main(String[] args) throws InterruptedException, BrokenBarrierException {
// 声明栅栏
CyclicBarrier barrier = new CyclicBarrier(3,() -> {
System.out.println("开始！");
});
new Thread(() -> {
System.out.println("第一位选手到位");
try {
barrier.await();
System.out.println("第一位往死里跑！");
} catch (Exception e) {
e.printStackTrace();
}
}).start();
new Thread(() -> {
System.out.println("第二位选手到位");
try {
barrier.await();
System.out.println("第二位也往死里跑！");
} catch (Exception e) {
e.printStackTrace();
}
}).start();
System.out.println("裁判已经到位");
barrier.await();
}
CyclicBarrier コアのソース コード
CyclicBarrier は AQS を直接使用しませんが、AQS を間接的に使用する ReentrantLock を使用します。
// CyclicBarrier的有参
public CyclicBarrier(int parties, Runnable barrierAction) {
、
// 健壮性判断！
if (parties <= 0) throw new IllegalArgumentException();
// parties是final修饰的，需要在重置时，使用！
this.parties = parties;
// count是在执行await用来计数的。
this.count = parties;
// 当计数count为0时 ，先执行这个Runnnable！在唤醒被阻塞的线程
this.barrierCommand = barrierAction;
}
スレッドが await メソッドを実行すると、カウントが 1 され、カウントが 0 かどうかが判断されます。0 でない場合は、AQS の ConditionObject の Waiter キューにスレッドを追加し、現在のスレッドをパークする必要があります。0 の場合は、スレッドの準備ができており、nextGeneration を実行する必要があることを示します。Waiter キュー内のすべてのノードが最初に AQS キューに転送され、後続ノードは 0 に設定されません。次に、カウントとブローカーのフラグをリセットします。ロック解除が実行されると、各スレッドが起動されます。
private int dowait(boolean timed, long nanos) throws InterruptedException, BrokenBarrierException, TimeoutException {
// 相当于synchronized中使用wait和notify
final ReentrantLock lock = this.lock;
lock.lock();
try {
// 里面就是boolean，默认false
final Generation g = generation;
// 判断之前栅栏加入线程时，是否有超时、中断等问题，如果有，设置boolean为true，其他线程再进来，直接凉凉
if (g.broken)
throw new BrokenBarrierException();
if (Thread.interrupted()) {
breakBarrier();
throw new InterruptedException();
}
// 对计数器count--
int index = --count;
// 如果--完，是0，代表突破栅栏，干活！
if (index == 0) {
// 默认false
boolean ranAction = false;
try {
// 如果你用的是2个参数的有参构造，说明你传入了任务，index == 0，先执行CyclicBarrier有参的任务
final Runnable command = barrierCommand;
if (command != null)
command.run();
// 设置为true
ranAction = true;
nextGeneration();
return 0;
} finally {
if (!ranAction)
breakBarrier();
}
}
// --完之后，index不是0，代表还需要等待其他线程
for (;;) {
try {
// 如果没设置超时时间。 await()
if (!timed)
trip.await();
// 设置了超时时间。 await(1,SECOND)
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();
}
}
// 挂起线程
public final void await() throws InterruptedException {
// 允许中断
if (Thread.interrupted())
throw new InterruptedException();
// 添加到队列（不是AQS队列，是AQS里的ConditionObject中的队列）
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
// 挂起当前线程
LockSupport.park(this);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
}
// count到0，唤醒所有队列里的线程线程
private void nextGeneration() {
// 这个方法就是将Waiter队列中的节点遍历都扔到AQS的队列中，真正唤醒的时机，是unlock方法
trip.signalAll();
// 重置计数器
count = parties;
// 重置异常判断
generation = new Generation();
}
要約する
これらのツール クラスを使用する場合の注意事項:
- セマフォを使用すると、過剰な同期によって引き起こされるデッドロックやパフォーマンスの問題を回避できます。
- バリア ポイント以降の CyclicBarrier のコードは、すべてのスレッドが正しく実行できることを保証する必要があります。そうしないと、一部のスレッドが永久に待機する可能性があります。
- CountDownLatch の countDown メソッドは、すべてのスレッドが実行を完了する前に呼び出す必要があります。そうしないと、一部のスレッドが待機し続ける可能性があります。
特定のアプリケーション シナリオに従って適切なツール クラスを選択し、それを正しく使用し、同時実行戦略を合理的に設計することで、プログラムの効率と信頼性を向上させることができます。