AQS 框架、JUC常见并发包简述

傷城~ 2024-02-20 11:57 48阅读 0赞

AQS（AbstractQueuedSynchronizer）是 Java 中的一个强大的同步框架，为我们提供了实现各种同步器的基础。在本篇博客中，我们将介绍 AQS 框架的基本原理，并探讨几个常见的 AQS 实现：ReentrantLock、CountDownLatch 和 Semaphore。我们将了解它们的区别以及各自的优缺点。

### 1. AQS 框架简介 ###

`AQS 是 Java 并发包中的核心部分`，它提供了一个基于 FIFO（first in first out `先进先出`）排队的双向链表等待队列，用于管理等待线程并控制资源的获取和释放。AQS 提供了一些核心的方法供子类继承和实现。下面我们重点介绍几个常见的 AQS 实现。

### 2. AQS 框架适用场景 ###

`AQS 用于单个服务内部的线程同步和并发控制`。适用于所有单体架构，或者微服务项目中单个服务内部的线程同步和并发控制。`不适用于分布式部署项目`，对于集群部署的微服务项目，需要额外考虑跨服务的分布式同步问题，并选择适合的分布式锁解决方案来实现分布式环境下的同步与控制。例如 `ZooKeeper、Redisson 等提供的分布式锁实现`

### 3. ReentrantLock（可重入锁） ###

ReentrantLock 是 AQS 框架的一个常见应用，`它提供了独占模式的锁`。多个线程可以重复获取和释放该锁，而不会因为重复获取而发生死锁。这个特性使得 ReentrantLock 可以用于更复杂的同步场景。

ReentrantLock内部使用了一个int变量来表示锁的持有状态,作为条件是占用资源,值为0时表示未锁定状态,大于0表示已锁定。

下面是一个简单的示例代码：

import java.util.concurrent.locks.ReentrantLock;
    public class ReentrantLockExample {
        
        private static ReentrantLock lock = new ReentrantLock();
        public static void main(String[] args) {
        
            lock.lock(); // 加锁，如果没有线程持有，则持有数加1返回。如果有线程持有，则持有数加1，并放到aqs等待队列排队
            try {
        
                // 执行保护的代码块
            } finally {
        
                lock.unlock(); // 释放锁，如果当前线程是此锁的持有者，则持有计数递减。如果保持计数现在为零，则释放锁。如果当前线程不是此锁的持有者，则抛出IllegalHonitorStateException
            }
        }
    }

ReentrantLock 的优点是提供了可重入性，支持公平和非公平模式，并且具有更丰富的功能。缺点是相对于 synchronized 关键字有更高的复杂性和更多的开销。

### 4. CountDownLatch（倒计时门栓） ###

CountDownLatch 是一个同步机制,`它允许一个或多个线程等待其他线程完成操作`,它的构造器将会接收一个整数参数,表示需要等待的线程数量。

CountDownLatch内部也使用AQS的等待队列实现等待线程的阻塞,使用一个int类型的计数器来表示需要等待的线程数。

具体实现过程:

构造时将计数器初始化为传入的参数值。

countDown()方法会让计数器值减1,如果计数器变为0了,则唤醒等待队列中所有的线程

await()方法会首先将当前线程添加到AQS的等待队列中,然后判断计数器是否为0,如果不为0则一直等待。

import java.util.concurrent.CountDownLatch;
    public class CountDownLatchExample {
        
        private static CountDownLatch latch = new CountDownLatch(3);
        public static void main(String[] args) throws InterruptedException {
        
            // 创建并启动多个线程
            for (int i = 0; i < 3; i++) {
        
                new Thread(() -> {
        
                    // 执行操作
                    latch.countDown(); // 操作完成后计数减1
                }).start();
            }
            latch.await(); // 等待计数为0
            // 所有操作完成后继续执行
        }
    }

CountDownLatch 的优点是简单易用，可以很方便地实现等待其他线程完成的场景。缺点是一旦计数值确定后就无法修改，并且只能使用一次。

### 5. Semaphore（信号量） ###

Semaphore 是一种控制并发访问资源数量的同步工具。`它允许多个线程同时访问共享资源`，但需要限制总的访问线程数量。Semaphore 通过 AQS 的计数和等待机制来控制线程的获取和释放。

Semaphore内部也是通过一个int值表示许可数量来实现的；  
acquire()方法会获取一个许可,如果没有就排队等待;  
release()方法会释放一个许可。

下面是一个简单的示例代码：

import java.util.concurrent.Semaphore;
    public class SemaphoreExample {
        
        private static Semaphore semaphore = new Semaphore(2);
        public static void main(String[] args) {
        
            // 创建并启动多个线程
            for (int i = 0; i < 5; i++) {
        
                new Thread(() -> {
        
                    try {
        
                        semaphore.acquire(); // 获取许可
                        // 访问共享资源
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    } finally {
        
                        semaphore.release(); // 释放许可
                    }
                }).start();
            }
        }
    }

Semaphore 的优点是可以控制资源的并发访问数量，可以用于限流等场景。缺点是相对于其他同步机制有更多的复杂性和开销。

### 总结 ###

**锁定对象:**

*  ReentrantLock是一种互斥锁,用于保护共享资源免受并发访问的侵害。
 *  CountDownLatch和Semaphore不是用来进行同步互斥的,CountDownLatch用来协调并行任务。
 *  Semaphore用来控制对共享资源的访问数量。

**实现原理:**

*  ReentrantLock使用状态变量表示锁的可重入性。
 *  CountDownLatch使用状态计数器,计数到0为0后释放所有等待线程。
 *  Semaphore使用许可证计数来控制可以访问的线程数量。

**使用场景:**

*  ReentrantLock用于同步访问的临界区。
 *  CountDownLatch用于等待一组异步任务完成。
 *  Semaphore用于控制对某种资源的并发数量。