java——AQS（AbstractQueuedSynchronizer）

AQS（AbstractQueuedSynchronizer）是Java并发包（java.util.concurrent）中的一个核心组件，是构建锁和其他同步器的基础框架。以下是对AQS的详细理解：

一、AQS的基本概念

AQS，全称为AbstractQueuedSynchronizer，是一个抽象的队列式同步器。它定义了一套多线程访问共享资源的同步器框架，为Java并发同步组件提供统一的底层支持。AQS是一个为各个同步组件提供基本框架的抽象类，其内部实现了同步状态的管理和线程的排队机制。

二、AQS的核心组件

1. 同步状态：AQS使用一个int类型的成员变量来表示同步状态。这个状态变量是线程共享的资源，通过内置的FIFO队列（先进先出队列）来完成获取资源线程的排队工作。
2. FIFO队列：AQS的底层实现是一个双向链表，用于管理等待获取同步状态的线程。当线程无法获取同步状态时，会被加入到这个队列中等待。
3. CLH队列锁：AQS使用CLH队列锁来实现线程的阻塞等待和唤醒机制。CLH是一个虚拟的双向队列，即不存在队列实例，仅存在节点之间的关联关系。

三、AQS的工作原理

1. 获取同步状态：当线程尝试获取同步状态时，会调用AQS的tryAcquire方法（对于独占模式）或tryAcquireShared方法（对于共享模式）。如果成功获取到同步状态，则返回true；否则，线程会被加入到等待队列中。
2. 释放同步状态：当线程释放同步状态时，会调用AQS的tryRelease方法（对于独占模式）或tryReleaseShared方法（对于共享模式）。这些方法会修改同步状态的值，并可能唤醒等待队列中的线程。
3. 线程排队与唤醒：等待获取同步状态的线程会被加入到FIFO队列中，并按照队列的顺序等待。当某个线程释放同步状态时，会唤醒队列中的下一个线程来尝试获取同步状态。

四、AQS的资源共享方式

AQS支持两种资源共享方式：独占（Exclusive）和共享（Share）。

1. 独占：只有一个线程能执行，如ReentrantLock。独占锁又可分为公平锁和非公平锁。公平锁按照线程在队列中的排队顺序来获取锁，非公平锁则允许线程无视队列顺序直接去抢锁。
2. 共享：多个线程可同时执行，如Semaphore、CountDownLatch、CyclicBarrier等。共享锁允许多个线程同时访问共享资源。

五、AQS的应用场景

AQS广泛应用于Java并发编程中，是实现各种同步机制的基础。例如，ReentrantLock、Semaphore、CountDownLatch等同步器都是基于AQS实现的。通过扩展AQS，开发者可以实现各种复杂的同步器，以满足不同的并发编程需求。

六、AQS的优缺点

优点：

1. 提供了统一的同步器框架，简化了同步器的实现过程。
2. 使用了FIFO队列来管理等待线程，保证了线程的公平性。
3. 提供了灵活的资源共享方式，支持独占和共享两种模式。

缺点：

1. AQS是一个相对复杂的框架，需要开发者对其内部机制有一定的了解才能正确使用。
2. 在某些情况下，AQS的性能可能不如一些定制的同步器。

七、AQS示例

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.LockSupport;

// 自定义锁类
class MyLock implements Lock {
    // 静态内部类，继承AQS
    private static class Sync extends AbstractQueuedSynchronizer {
        // 是否处于独占模式
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        // 尝试获取锁，当状态为0时获取锁成功
        public boolean tryAcquire(int acquires) {
            assert acquires == 1; // 只允许获取1个单位的锁
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 尝试释放锁，将状态设置为0
        protected boolean tryRelease(int releases) {
            assert releases == 1; // 只允许释放1个单位的锁
            if (getState() == 0) throw new IllegalMonitorStateException();
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }

        // 提供条件变量
        Condition newCondition() { return new ConditionObject(); }
    }

    // 将操作代理到Sync上
    private final Sync sync = new Sync();

    // 实现Lock接口的方法
    @Override
    public void lock() {
        sync.acquire(1);
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        sync.acquireInterruptibly(1);
    }

    @Override
    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return sync.tryAcquireNanos(unit.toNanos(time));
    }

    @Override
    public void unlock() {
        sync.release(1);
    }

    @Override
    public Condition newCondition() {
        return sync.newCondition();
    }

    public static void main(String[] args) {
        MyLock lock = new MyLock();

        Runnable task = () -> {
            lock.lock();
            try {
                System.out.println(Thread.currentThread().getName() + " 获取锁");
                // 模拟任务执行
                LockSupport.parkNanos(TimeUnit.SECONDS.toNanos(1));
            } finally {
                System.out.println(Thread.currentThread().getName() + " 释放锁");
                lock.unlock();
            }
        };

        Thread t1 = new Thread(task, "Thread-1");
        Thread t2 = new Thread(task, "Thread-2");

        t1.start();
        t2.start();
    }
}

1. MyLock类：实现Lock接口，内部包含一个静态内部类Sync，该内部类继承自AbstractQueuedSynchronizer。
2. Sync类：
   • isHeldExclusively：判断当前线程是否持有锁。
   • tryAcquire：尝试获取锁，如果当前状态为0（表示锁未被持有），则通过compareAndSetState方法将状态设置为1，并设置当前线程为独占线程。
   • tryRelease：尝试释放锁，将状态设置为0，并清除独占线程。
   • newCondition：创建一个条件变量。
3. MyLock方法：将Lock接口的方法代理到Sync对象上。
4. main方法：创建两个线程，每个线程尝试获取和释放锁，模拟任务执行。