CountDownLatch
它允许一个线程等待其他线程完成执行。当所有需要等待的线程都完成后，CountDownLatch会释放一个信号，通知所有等待的线程继续执行。
使用介绍
初始化：创建一个CountDownLatch实例时，需要指定一个计数器（count）的值。这个值表示需要等待的操作数量。
减少计数器：当一个操作完成时，调用CountDownLatch的countDown()方法，将计数器的值减1。
阻塞等待：在计数器值为0之前，调用await()方法的线程会被阻塞。一旦计数器的值变为0，所有等待的线程将被唤醒并继续执行。
重置：CountDownLatch没有提供重置计数器的方法。如果需要重新开始等待，需要重新创建一个新的CountDownLatch实例。
示例
import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
public static void main(String[] args) throws InterruptedException {
int numberOfThreads = 3;
CountDownLatch latch = new CountDownLatch(numberOfThreads);
for (int i = 0; i < numberOfThreads; i++) {
new Thread(new Worker(latch)).start();
}
// 主线程等待所有工作线程完成任务
latch.await();
System.out.println("所有工作线程已完成任务");
}
static class Worker implements Runnable {
private final CountDownLatch latch;
public Worker(CountDownLatch latch) {
this.latch = latch;
}
@Override
public void run() {
try {
// 模拟工作线程执行任务
System.out.println(Thread.currentThread().getName() + "正在执行任务...");
Thread.sleep((long) (Math.random() * 1000));
System.out.println(Thread.currentThread().getName() + "任务完成");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 完成任务后，计数器减一
latch.countDown();
}
}
}
}
在这个示例中，我们创建了一个CountDownLatch实例，其计数器初始值为3（表示需要等待3个线程完成任务）。然后，我们创建了3个工作线程，每个线程在完成任务后调用latch.countDown()来减少计数器的值。主线程通过调用latch.await()来等待所有工作线程完成任务。当计数器的值变为0时，latch.await()会返回，主线程继续执行后续操作。
CyclicBarrier
CyclicBarrier可以让一组线程在达到某个屏障时被阻塞，直到最后一个线程到达屏障后，所有被阻塞的线程才能继续执行。
使用介绍
初始化：创建一个CyclicBarrier实例时，需要指定一个参与者数量（parties），表示需要等待的线程数量。还可以提供一个可选的Runnable任务，当所有线程都到达屏障时执行。
等待：每个线程在调用await()方法时会被阻塞，直到所有线程都调用了await()方法。如果某个线程在等待过程中被中断，它将抛出InterruptedException异常。
唤醒：当最后一个线程调用await()方法后，屏障将打开，所有等待的线程将被唤醒。如果有提供Runnable任务，它将在所有线程被唤醒后执行。
重置：CyclicBarrier没有提供重置的方法。但是，它的设计初衷是为了重复使用，因此可以在下一次需要时再次创建一个新的CyclicBarrier实例。
示例
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.BrokenBarrierException;
public class CyclicBarrierExample {
public static void main(String[] args) {
int numberOfThreads = 3;
CyclicBarrier barrier = new CyclicBarrier(numberOfThreads, () -> System.out.println("所有线程已准备好，继续执行！"));
for (int i = 0; i < numberOfThreads; i++) {
new Thread(new Worker(barrier)).start();
}
}
static class Worker implements Runnable {
private final CyclicBarrier barrier;
public Worker(CyclicBarrier barrier) {
this.barrier = barrier;
}
@Override
public void run() {
try {
System.out.println(Thread.currentThread().getName() + "正在准备...");
Thread.sleep((long) (Math.random() * 1000));
System.out.println(Thread.currentThread().getName() + "准备完毕，等待其他线程...");
barrier.await();
System.out.println(Thread.currentThread().getName() + "开始执行任务...");
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
}
在这个示例中，我们创建了一个CyclicBarrier实例，其参与者数量为3（表示需要等待3个线程准备好）。然后，我们创建了3个工作线程，每个线程在准备好后调用barrier.await()来等待其他线程。当所有线程都调用了await()方法后，CyclicBarrier会执行指定的Runnable（在这个例子中是一个lambda表达式），然后所有线程继续执行后续操作。
Semaphore
Semaphore信号量，是一种用于控制多线程对共享资源访问的同步工具类，它通过维护一个许可证集来限制同时访问资源的线程数量。
使用介绍
初始化：创建一个Semaphore实例时，需要指定一个初始许可数（permits）。这个许可数表示同时可以访问共享资源的线程数量。
获取许可：当一个线程需要访问共享资源时，它会调用acquire()方法来获取一个许可。如果当前可用许可数大于0，那么线程将立即获得许可并继续执行；否则，线程将被阻塞，直到其他线程释放许可。
释放许可：当线程完成对共享资源的访问后，它会调用release()方法来释放许可。这将使等待许可的线程中的一个（如果有的话）能够继续执行。
计数器：Semaphore内部维护一个计数器，用于跟踪当前可用的许可数。每当一个线程获取许可时，计数器减1；每当一个线程释放许可时，计数器加1。
示例
import java.util.concurrent.Semaphore;
public class SemaphoreExample {
public static void main(String[] args) {
// 创建一个Semaphore实例，初始许可数量为3
Semaphore semaphore = new Semaphore(3);
// 创建5个线程
for (int i = 1; i <= 5; i++) {
final int threadId = i;
new Thread(() -> {
try {
// 获取许可
semaphore.acquire();
System.out.println("线程" + threadId + "获取到许可，开始执行任务...");
Thread.sleep((long) (Math.random() * 1000));
System.out.println("线程" + threadId + "完成任务，释放许可...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放许可
semaphore.release();
}
}).start();
}
}
}
在这个示例中，我们创建了一个Semaphore实例，初始许可数量为3。然后创建了5个线程，每个线程在执行任务前需要获取许可。当一个线程获取到许可后，它会执行任务，完成后释放许可。由于Semaphore的许可数量限制为3，因此最多只有3个线程可以同时执行任务。其他线程需要等待已有线程释放许可后才能继续执行。
实现原理
上述三个类内部通过AbstractQueuedSynchronizer实现线程安全，源码如下所示：
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) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
private final Sync sync;
AbstractQueuedSynchronizer（AQS）是Java并发包中的一个抽象类，它为实现依赖于先进先出（FIFO）等待队列的阻塞锁和相关同步器提供了一个框架。AQS维护了一个共享资源的状态，并提供了一组方法来管理线程对资源的访问。
AQS的主要特点如下：
-
阻塞模式和非阻塞模式：AQS支持阻塞模式和非阻塞模式。在阻塞模式下，线程会进入等待状态直到获得资源；而在非阻塞模式下，线程尝试获取资源，如果无法立即获得，则返回失败。
-
公平性：AQS允许实现公平锁和非公平锁。公平锁保证等待时间最长的线程优先获得资源，而非公平锁则不保证这一点。
-
可重入性：AQS支持可重入锁，即同一个线程可以多次获取同一把锁而不会导致死锁。
-
条件变量：AQS提供了条件变量的概念，允许线程在某个条件成立时被唤醒。这通常用于实现生产者-消费者模式。
AQS的主要组件包括：
- state：表示资源的状态，可以是任意类型的整数或枚举类型。
- FIFO队列：用于存储等待资源的线程。
- 独占模式和非独占模式：独占模式表示只有一个线程可以持有资源，而非独占模式允许多个线程同时持有资源。
AQS提供了一些重要的方法，如acquire(), release(), tryAcquire(), tryRelease()等，这些方法可以被具体的锁和同步器实现类覆盖以提供特定的行为。
扫一扫
510
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
