理解Java中的AQS

一、定义

AQS:AbstractQueuedSynchronizer(抽象队列同步器)，是一个用于构建锁和同步器的抽象的同步框架。AQS 提供了一种可扩展的基础，允许开发者实现各种形式的同步控制机制。
例如：独占锁（ReentrantLock）、共享锁（ReentrantReadWriteLock）、CountDownLatch 等都是基于 AQS 的同步机制实现的。

AQS 的核心思想是基于队列的等待/通知机制。它维护了一个等待队列，线程通过排队在队列中等待获取锁或者资源。AQS 提供了一些基本的方法，允许子类来定义自己的同步逻辑。其中两个主要的模板方法是 acquire 和 release。

• acquire 方法用于线程获取锁或资源，如果获取不到就进入等待队列等待。
• release 方法用于线程释放锁或资源，可能会唤醒等待队列中的其他线程。

AQS 的实现使用了模板方法模式，具体的同步器通过继承 AQS 并实现其中的抽象方法来定义自己的同步逻辑。

二、CountDownLatch

CountDownLatch 是 Java 中并发编程的一个工具类，用于实现线程等待。使用了 AQS 的基本机制，通过维护一个计数器，使得等待的线程能够在计数器减为零时被唤醒。

CountDownLatch 的主要方法是 countDown() 和 await()：

• countDown(): 每次调用都会将计数器减1。
• 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

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();
        }
    }
}