面试必备之并发原语AQS

lqstyle
64 阅读7分钟

从排队买奶茶到AQS：并发编程的奇妙冒险

引言：排队买奶茶的哲学

你有没有想过，排队买奶茶其实是一场微型的社会实验？当你站在队伍中，前面有10个人，后面也有10个人，你会不会思考：“为什么我不能插队？为什么我不能同时让10个店员为我服务？”如果你曾经有过这样的想法，恭喜你，你已经迈出了理解并发编程的第一步！

在并发编程的世界里，AQS（
AbstractQueuedSynchronizer）就像是一个高效的奶茶店排队系统。它不仅能让你有序地排队，还能让你在适当的时候“插队”（当然，是在规则允许的情况下）。今天，我们就来聊聊AQS，这个并发编程中的“奶茶店排队系统”。

第一章：并发编程的烦恼

1.1 什么是并发编程？

并发编程是指在同一时间段内，多个任务同时执行。想象一下，你正在写代码，突然你的电脑同时运行了10个任务：下载文件、播放音乐、编译代码、打开浏览器……这些任务都在争夺CPU的资源，就像一群人在奶茶店门口争抢位置。

1.2 为什么并发编程这么难？

并发编程的难点在于“竞争条件”。当多个任务同时访问共享资源时，可能会出现意想不到的结果。比如，你和朋友同时点击“购买”按钮，结果系统只处理了一个请求，另一个请求被忽略了。这就是并发编程中的“竞态条件”。

1.3 锁的出现：从混乱到有序

为了解决这个问题，程序员们发明了“锁”。锁就像奶茶店的门，只有拿到钥匙（锁）的人才能进去买奶茶。其他人只能在门外等待。锁的出现让并发编程变得有序，但也带来了新的问题：死锁、饥饿、性能瓶颈……

第二章：AQS的诞生

2.1 AQS是什么？

AQS（
AbstractQueuedSynchronizer）是Java并发包中的一个核心组件，它提供了一种实现锁和其他同步器的框架。你可以把它想象成一个超级智能的奶茶店排队系统，它不仅能让顾客有序排队，还能根据情况动态调整队伍。

2.2 AQS的核心思想

AQS的核心思想是“队列”和“状态”。它通过一个FIFO（先进先出）的队列来管理等待锁的线程，并通过一个整型的“状态”来表示锁的占用情况。这个状态可以是0（未锁定）或1（锁定），也可以是其他自定义的值。

2.3 AQS的两种模式

AQS支持两种模式：独占模式和共享模式。

  • 独占模式：就像奶茶店只有一个店员，一次只能服务一个顾客。其他顾客必须等待。
  • 共享模式：就像奶茶店有多个店员，可以同时服务多个顾客。多个线程可以同时获取锁。

第三章：AQS的实现细节

3.1 队列的管理

AQS使用一个双向链表来管理等待锁的线程。每个线程都会被封装成一个节点（Node），并加入到队列中。当锁被释放时，AQS会从队列的头部取出一个节点，唤醒对应的线程。

volatile的作用

  1. 保证可见性：当一个线程修改了volatile变量的值，其他线程能立即看到这个变化。
  2. 禁止指令重排序：JVM和CPU为了提高性能，可能会对指令进行重排序。volatile可以防止这种重排序，保证代码的执行顺序符合预期。
  3. 不能保证原子性

3.2 状态的维护

AQS通过一个volatile的int变量来维护锁的状态。这个变量可以被多个线程同时访问，因此AQS使用CAS（Compare-And-Swap）操作来保证状态的原子性更新。

3.3 自定义同步器

AQS是一个抽象类，你可以通过继承它来实现自己的同步器。你只需要重写tryAcquire和tryRelease方法（独占模式）或tryAcquireShared和tryReleaseShared方法（共享模式），就可以实现自定义的锁或同步器。

第四章：AQS的应用场景

4.1 ReentrantLock

ReentrantLock是AQS的一个典型应用。它支持重入锁，即同一个线程可以多次获取同一个锁。你可以把它想象成一个VIP顾客，他可以多次进入奶茶店，而不需要重新排队。

4.2 Semaphore

Semaphore是AQS的另一个应用，它用于控制同时访问某个资源的线程数量。你可以把它想象成一个限流的奶茶店，店里最多只能容纳10个顾客，超过的顾客必须等待。

发令枪

import java.util.concurrent.Semaphore;

public class RaceWithSemaphore {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个Semaphore，初始许可数为0（所有线程都需要等待）
        Semaphore startingGun = new Semaphore(0);

        // 创建5个线程，代表5个运动员
        for (int i = 1; i <= 5; i++) {
            Thread runner = new Thread(new Runner(startingGun), "Runner-" + i);
            runner.start();
        }

        // 模拟发令员准备时间
        System.out.println("发令员正在准备...");
        Thread.sleep(2000); // 等待2秒

        // 发令枪响，释放所有许可，唤醒所有等待的线程
        System.out.println("发令枪响了！");
        startingGun.release(5); // 释放5个许可，唤醒所有运动员
    }

    // 运动员线程
    static class Runner implements Runnable {
        private final Semaphore startingGun;

        public Runner(Semaphore startingGun) {
            this.startingGun = startingGun;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " 已就位，等待发令枪...");
                startingGun.acquire(); // 等待发令枪响
                System.out.println(Thread.currentThread().getName() + " 开始跑步！");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

4.3 CountDownLatch

CountDownLatch是AQS的一个同步工具，它允许一个或多个线程等待其他线程完成操作。你可以把它想象成一个团队点奶茶的场景，只有当所有人都点完奶茶后，才能一起离开。

发令枪

import java.util.concurrent.CountDownLatch;

public class RaceWithCountDownLatch {

    public static void main(String[] args) throws InterruptedException {
        // 创建一个CountDownLatch，初始值为1（发令枪只需要响一次）
        CountDownLatch startingGun = new CountDownLatch(1);

        // 创建5个线程，代表5个运动员
        for (int i = 1; i <= 5; i++) {
            Thread runner = new Thread(new Runner(startingGun), "Runner-" + i);
            runner.start();
        }

        // 模拟发令员准备时间
        System.out.println("发令员正在准备...");
        Thread.sleep(2000); // 等待2秒

        // 发令枪响，所有运动员开始跑步
        System.out.println("发令枪响了！");
        startingGun.countDown(); // 将CountDownLatch的值减1，唤醒所有等待的线程
    }

    // 运动员线程
    static class Runner implements Runnable {
        private final CountDownLatch startingGun;

        public Runner(CountDownLatch startingGun) {
            this.startingGun = startingGun;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " 已就位，等待发令枪...");
                startingGun.await(); // 等待发令枪响
                System.out.println(Thread.currentThread().getName() + " 开始跑步！");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
}

第五章：AQS的思考与联想

5.1 AQS与操作系统

AQS的队列管理机制与操作系统中的进程调度非常相似。操作系统通过调度算法来决定哪个进程可以获得CPU资源，而AQS通过队列来决定哪个线程可以获得锁。你可以把AQS看作是一个微型的操作系统调度器。

5.2 AQS与数据库锁

AQS的独占模式和共享模式与数据库中的行级锁非常相似。数据库中的行级锁也分为独占锁和共享锁，分别用于控制对数据的读写操作。你可以把AQS看作是一个简化版的数据库锁管理器。

5.3 AQS与分布式系统

AQS的队列和状态管理机制也可以应用于分布式系统中。在分布式系统中，多个节点需要协调访问共享资源，AQS的思想可以帮助我们设计出高效的分布式锁。

结语：从AQS到人生哲学

AQS不仅仅是一个技术工具，它还蕴含着深刻的人生哲学。在并发编程中，我们需要学会等待、学会竞争、学会合作。正如在奶茶店排队一样，有时候我们需要耐心等待，有时候我们需要抓住机会，有时候我们需要与他人合作。

所以，下次当你排队买奶茶时，不妨想想AQS，想想并发编程，想想人生的竞争与合作。或许，你会对这个世界有新的理解。

思考题：如果你是一个奶茶店的老板，你会如何设计一个高效的排队系统？你会使用AQS的思想吗？欢迎在评论区分享你的想法！

知识增量：通过本文，你不仅了解了AQS的基本原理和应用场景，还联想到了操作系统、数据库锁和分布式系统中的相关知识。希望这些知识能帮助你在并发编程的道路上走得更远！

avatar
文章
阅读
粉丝