AQS:AbstractQueuedSynchronizer(抽象队列同步器),是一个用于构建锁和同步器的抽象的同步框架
。AQS 提供了一种可扩展的基础,允许开发者实现各种形式的同步控制机制
。
例如:独占锁(ReentrantLock)、共享锁(ReentrantReadWriteLock)、CountDownLatch 等都是基于 AQS 的同步机制实现的。
AQS 的核心思想
是基于队列的等待/通知机制
。它维护了一个等待队列,线程通过排队在队列中等待获取锁或者资源。AQS 提供了一些基本的方法,允许子类来定义自己的同步逻辑。其中两个主要的模板方法是 acquire 和 release
。
AQS 的实现
使用了模板方法模式,具体的同步器通过继承 AQS 并实现其中的抽象方法来定义自己的同步逻辑。
CountDownLatch 是 Java 中并发编程的一个工具类,用于实现线程等待。使用了 AQS 的基本机制,通过维护一个计数器,使得等待的线程能够在计数器减为零时被唤醒。
CountDownLatch 的主要方法是 countDown() 和 await():
import java.util.concurrent.CountDownLatch;
public class CountDownLatchExample {
public static void main(String[] args) {
// 创建一个CountDownLatch,设置初始计数器值
CountDownLatch latch = new CountDownLatch(3);
// 创建三个线程,并传递同一个CountDownLatch实例
Thread worker1 = new Worker(latch, "Worker 1");
Thread worker2 = new Worker(latch, "Worker 2");
Thread worker3 = new Worker(latch, "Worker 3");
// 启动三个线程
worker1.start();
worker2.start();
worker3.start();
try {
// 主线程等待计数器变为零
latch.await();
System.out.println("All workers have completed their tasks.");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class Worker extends Thread {
private final CountDownLatch latch;
public Worker(CountDownLatch latch, String name) {
super(name);
this.latch = latch;
}
@Override
public void run() {
System.out.println(getName() + " is working.");
// 模拟工作任务
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + " has completed its task.");
// 每个线程完成任务时调用countDown()
latch.countDown();
}
}
ReentrantLock 是 java.util.concurrent.locks 包中用于实现可重入锁
(Reentrant Lock)的类,使用 AQS 来实现同步。它提供了比传统的synchronized关键字更灵活的锁定机制。可重入锁允许线程在持有锁的情况下再次获取该锁,而不会发生死锁。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockExample {
public static void main(String[] args) {
// 创建一个ReentrantLock实例
Lock lock = new ReentrantLock();
// 创建两个线程,并传递同一个ReentrantLock实例
Thread thread1 = new Worker(lock, "Thread 1");
Thread thread2 = new Worker(lock, "Thread 2");
// 启动两个线程
thread1.start();
thread2.start();
}
}
class Worker extends Thread {
private final Lock lock;
public Worker(Lock lock, String name) {
super(name);
this.lock = lock;
}
@Override
public void run() {
// 获取锁
lock.lock();
try {
System.out.println(getName() + " has acquired the lock.");
// 模拟工作任务
Thread.sleep(2000);
System.out.println(getName() + " is releasing the lock.");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放锁,确保在发生异常时也能释放锁
lock.unlock();
}
}
}