3.Java面试题之AQS

1. 写在前面

在这里插入图片描述

AQS（AbstractQueuedSynchronizer）是Java并发包（java.util.concurrent）中的一个抽象类，用于实现同步器（如锁、信号量、栅栏等）。AQS提供了一种基于FIFO队列的机制来管理线程的竞争和等待状态。其主要作用是简化同步器的实现，通过提供通用的同步状态管理和线程排队机制，使得开发者可以专注于特定同步器的逻辑。了解AQS的工作原理和应用场景是高级Java开发者需要掌握的重要技能。以下是一些常见的AQS面试题及其详细解答。

2. AQS的工作原理是什么？

AQS的核心工作原理基于一个FIFO等待队列和一个同步状态（state）。其主要步骤如下：

同步状态：AQS通过一个 int 类型的变量 state 来表示同步状态。子类通过重写 tryAcquire、tryRelease 等方法来定义获取和释放同步状态的逻辑。
等待队列：当线程无法获取同步状态时，会被加入到AQS的FIFO等待队列中，队列中的每个节点（Node）表示一个等待的线程。
独占模式和共享模式：AQS支持独占模式（如独占锁）和共享模式（如共享锁、信号量）。在独占模式下，只有一个线程可以获取同步状态；在共享模式下，多个线程可以同时获取同步状态。
模板方法：AQS通过模板方法模式提供了通用的同步机制，子类只需实现特定的同步逻辑。

3. AQS中的Node节点是什么？其作用是什么？

AQS中的Node节点是一个内部类 AbstractQueuedSynchronizer.Node，用于表示等待队列中的每个线程。Node节点包含以下重要信息：

线程引用：表示当前节点所关联的线程。
等待状态：表示当前节点的等待状态，如 SIGNAL（等待唤醒）、CANCELLED（取消）等。
前驱和后继节点：用于在等待队列中形成双向链表。
模式：表示当前节点是独占模式还是共享模式。

Node节点的作用是管理等待队列中的线程状态和排队顺序，确保线程能够按照FIFO顺序被唤醒和执行。

4. AQS中的独占模式和共享模式有什么区别？

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

4.1 独占模式

只有一个线程可以获取同步状态
典型应用：独占锁（如 ReentrantLock）
主要方法：tryAcquire、tryRelease

4.2 共享模式

多个线程可以同时获取同步状态
典型应用：共享锁（如 ReadWriteLock 中的读锁）、信号量（如 Semaphore）
主要方法：tryAcquireShared、tryReleaseShared

5. 如何使用AQS实现一个简单的独占锁？

可以通过继承AQS并重写其方法来实现一个简单的独占锁。以下是一个示例：

import java.util.concurrent.locks.AbstractQueuedSynchronizer;public class SimpleLock {private static class Sync extends AbstractQueuedSynchronizer {@Overrideprotected boolean tryAcquire(int arg) {if (compareAndSetState(0, 1)) {setExclusiveOwnerThread(Thread.currentThread());return true;}return false;}@Overrideprotected boolean tryRelease(int arg) {if (getState() == 0) throw new IllegalMonitorStateException();setExclusiveOwnerThread(null);setState(0);return true;}protected boolean isHeldExclusively() {return getState() == 1;}}private final Sync sync = new Sync();public void lock() {sync.acquire(1);}public void unlock() {sync.release(1);}public boolean isLocked() {return sync.isHeldExclusively();}
}

6. 如何使用AQS实现一个简单的共享锁？

可以通过继承AQS并重写其方法来实现一个简单的共享锁。以下是一个示例：

import java.util.concurrent.locks.AbstractQueuedSynchronizer;public class SimpleSharedLock {private static class Sync extends AbstractQueuedSynchronizer {@Overrideprotected int tryAcquireShared(int arg) {for (;;) {int current = getState();int newCount = current + arg;if (compareAndSetState(current, newCount)) {return newCount;}}}@Overrideprotected boolean tryReleaseShared(int arg) {for (;;) {int current = getState();int newCount = current - arg;if (compareAndSetState(current, newCount)) {return newCount == 0;}}}}private final Sync sync = new Sync();public void lock() {sync.acquireShared(1);}public void unlock() {sync.releaseShared(1);}
}

7. AQS的公平锁和非公平锁有什么区别？

AQS支持公平锁和非公平锁两种模式：

7.1 公平锁

线程按照FIFO顺序获取锁，先到先得。
公平锁避免了线程饥饿，但可能会导致较高的上下文切换开销。
典型实现：ReentrantLock 的公平模式。

7.2 非公平锁

线程可以插队获取锁，不保证FIFO顺序。
非公平锁可能会导致线程饥饿，但通常性能较高，因为减少了上下文切换。
典型实现：ReentrantLock 的非公平模式（默认）。

8. AQS的Condition机制是如何实现的？

AQS的Condition机制通过内部类 ConditionObject 实现。ConditionObject 提供了 await 和 signal 等方法，用于线程的等待和唤醒。其工作原理如下：

等待队列：每个Condition对象都有一个单独的等待队列，线程调用 await 方法时，会被加入到该等待队列中，并释放当前持有的锁。
唤醒机制：线程调用 signal 方法时，会从等待队列中唤醒一个线程，并将其移到同步队列中，等待获取锁。

import java.util.concurrent.locks.AbstractQueuedSynchronizer;
import java.util.concurrent.locks.Condition;public class SimpleLockWithCondition {private static class Sync extends AbstractQueuedSynchronizer {@Overrideprotected boolean tryAcquire(int arg) {if (compareAndSetState(0, 1)) {setExclusiveOwnerThread(Thread.currentThread());return true;}return false;}@Overrideprotected boolean tryRelease(int arg) {if (getState() == 0) throw new IllegalMonitorStateException();setExclusiveOwnerThread(null);setState(0);return true;}protected boolean isHeldExclusively() {return getState() == 1;}Condition newCondition() {return new ConditionObject();}}private final Sync sync = new Sync();public void lock() {sync.acquire(1);}public void unlock() {sync.release(1);}public Condition newCondition() {return sync.newCondition();}
}