理解Java中的AQS

发布时间:2024年01月23日

一、定义

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();
        }
    }
}
文章来源:https://blog.csdn.net/weixin_40497710/article/details/135790239
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。