Java进阶篇--AQS(AbstractQueuedSynchronizer)

正在奋斗的程序猿

已于 2023-10-23 17:28:01 修改

阅读量151

点赞数 2

分类专栏： Java进阶篇文章标签： java 开发语言

于 2023-10-15 21:48:19 首次发布

本文链接：https://blog.csdn.net/m0_74293254/article/details/133847265

版权

Java进阶篇专栏收录该内容

44 篇文章 1 订阅

订阅专栏

AQS简介

AQS（AbstractQueuedSynchronizer）是Java并发包中的一个基础框架，用于实现同步器的构建。它通过提供了一组底层的原子操作和状态管理机制，使得开发者可以相对容易地构建各种高性能的同步器。

AQS作为一个抽象类，为具体的同步器提供了一些通用的模板方法，其中最重要的是acquire和release方法。acquire用于获取锁或者资源，release用于释放锁或者资源。这两个方法是实现同步器的关键。AQS通过维护一个FIFO的等待队列来管理线程的竞争和等待。

AQS的核心思想是使用一个整形的state值来表示同步状态，state的语义由具体的同步器决定，可以表示锁的可重入次数、资源的数量等。通过CAS（Compare and Swap）原子操作来修改state的值，实现线程的安全竞争。

AQS提供了两种同步器的实现方式：独占式和共享式。独占式同步器只允许一个线程获取锁或者资源，比如ReentrantLock就是一个独占式同步器的实现。而共享式同步器允许多个线程同时获取锁或者资源，比如Semaphore就是一个共享式同步器的实现。

对于独占式同步器，AQS提供了tryAcquire和tryRelease等方法供具体的同步器实现。这些方法需要开发者根据具体的业务逻辑实现，并且要保证线程安全。在调用acquire时，如果获取不到锁或者资源，线程会被加入到等待队列中进行阻塞。而在调用release时，会释放锁或者资源，并唤醒等待队列中的其他线程。

AQS的使用并不直接对外暴露，而是通过具体的同步器（如ReentrantLock、Semaphore等）来间接使用。开发者可以通过继承AQS，重写其中的方法，实现自定义的同步器。在使用AQS构建同步器时，需要注意线程安全性和性能问题，合理地选择同步方式和状态的管理方式。

总的来说，AQS是Java并发包中一个非常重要的基础框架，通过它可以相对容易地构建各种高性能的同步器。熟练掌握AQS的原理和使用方法，对于进阶的Java开发非常有帮助。在学习这些模板方法之前，我们得首先了解下AQS中的同步队列是一种什么样的数据结构，因为同步队列是AQS对同步状态的管理的基石。

同步队列

AQS（AbstractQueuedSynchronizer）中的同步队列使用链式方式进行实现。具体来说，AQS中的同步队列是通过双向链表的形式构建的。

在AQS中，每个等待获取锁的线程都会被封装成一个节点（Node），该节点包含了线程的相关信息以及在同步队列中的前驱和后继节点的引用。

当一个线程请求获取锁时，如果锁已经被占用，则该线程会被封装成一个节点，并加入到同步队列的尾部，并进入等待状态。这个节点的前驱节点就是队列中的最后一个节点。

当锁释放时，AQS会唤醒同步队列中的头节点所对应的线程，使他们能够竞争获取锁。同时，被唤醒的线程将会从等待状态恢复到可运行状态，并尝试再次获取锁。

通过链式的方式实现同步队列的好处是，可以灵活地进行节点的插入和删除操作，同时便于实现线程的等待和唤醒机制。

扩展知识

在AQS中，节点的入队和出队操作是对应于锁的获取和释放操作的。节点的入队操作是通过enq()方法实现的，而节点的出队操作则是通过unparkSuccessor()方法实现的。

节点的入队（获取锁失败）操作：

1、当一个线程请求获取锁时，如果锁已经被占用，则该线程会被封装成一个节点，并调用enq()方法将节点加入到同步队列的尾部。
2、enq()方法首先会将当前线程封装成一个节点，并使用自旋+CAS操作将节点添加到同步队列的尾部。具体的步骤包括：

如果同步队列为空，则创建一个头节点（head节点）并将其设置为同步队列的首尾节点；
如果同步队列不为空，则使用自旋+CAS操作将新创建的节点添加到同步队列的尾部。

节点的出队（获取锁成功）操作：

1、当一个线程成功获取到锁时，需要从同步队列中移除自己所对应的节点，以便其他线程能够继续竞争锁。

2、unparkSuccessor()方法会唤醒同步队列中处于等待状态的后继节点，并将已经获取到锁的节点从同步队列中移除。

3、具体的步骤包括：

首先，unparkSuccessor()方法会通过CAS操作将同步队列的头节点指向当前线程所对应的后继节点；
接着，它会通过LockSupport.unpark()唤醒后继节点所对应的线程，使其从等待状态恢复到可运行状态；
最后，通过将已经获取到锁的节点的prev、next等属性设置为null，将该节点从同步队列中移除。

通过这样的方式，AQS实现了基于同步队列的锁的获取和释放操作。锁的获取失败时，线程会被加入到同步队列中等待；而锁的获取成功时，线程会被从同步队列中移除，同时唤醒后继节点继续竞争锁。

代码示例

import java.util.concurrent.locks.AbstractQueuedSynchronizer;

/**
 * @author 86193
 */
public class Main {

    static final class Sync extends AbstractQueuedSynchronizer {
        // 重写尝试获取锁的方法，返回当前状态值是否为0
        @Override
        protected boolean isHeldExclusively() {
            return getState() == 1;
        }

        // 如果状态为0，则尝试获取锁，如果成功则返回true，否则返回false
        @Override
        public boolean tryAcquire(int ignore) {
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread());
                return true;
            }
            return false;
        }

        // 尝试释放锁，并将状态值重置为0
        @Override
        protected boolean tryRelease(int ignore) {
            setExclusiveOwnerThread(null);
            setState(0);
            return true;
        }
    }

    // 创建Sync对象来实现同步操作
    private final Sync sync = new Sync();

    // 入队操作
    public void enqueue() {
        sync.acquire(1);
        try {
            // 实现入队的逻辑
            System.out.println("入队");
        } finally {
            sync.release(1);
        }
    }

    // 出队操作
    public void dequeue() {
        sync.acquire(1);
        try {
            // 实现出队的逻辑
            System.out.println("出队");
        } finally {
            sync.release(1);
        }
    }

    public static void main(String[] args) {
        final Main queue = new Main();
        new Thread(queue::enqueue).start();
        new Thread(queue::dequeue).start();
    }
}

其中，同步队列的实现通过继承AbstractQueuedSynchronizer来进行，具体实现方法包括：

重写isHeldExclusively方法：该方法判断当前线程是否持有锁，返回当前状态值是否为1；
重写tryAcquire方法：该方法尝试获取锁，如果状态值为0，则将其设置为1，同时设置当前线程为独占线程（即持有锁的线程）；
重写tryRelease方法：该方法尝试释放锁，将状态值设为0，同时将独占线程设为null。

在SyncQueueDemo中，enqueue和dequeue方法分别用于入队和出队操作。在进入操作前需要调用sync.acquire(1)获取锁，然后执行相应的操作，最后再通过sync.release(1)释放锁。

在main方法中，我们启动两个线程分别执行enqueue和dequeue操作，模拟一个生产者消费者的场景。

独占锁

独占锁（Exclusive Lock），也称为互斥锁，是一种线程同步的机制，用于保护共享资源在同一时间只能被一个线程访问。Java 提供了多种实现独占锁的方式，包括synchronized关键字、ReentrantLock类等。

独占锁的获取（acquire方法）：在 Java 中，可以使用 ReentrantLock 类来实现独占锁的获取。通过调用 ReentrantLock 对象的 lock() 方法，可以获取独占锁。如果当前锁已经被其他线程获取，则当前线程会进入阻塞状态，直到获取到锁为止。
独占锁的释放（release()方法）：通过调用 ReentrantLock 对象的 unlock() 方法，可以释放已经获取到的独占锁。释放锁的操作应该放在 finally 块中，确保无论是否发生异常都能正确释放锁。
可中断式获取锁（acquireInterruptibly方法）： ReentrantLock 类还提供了 acquireInterruptibly() 方法，该方法可以在获取独占锁时响应中断。如果当前线程在获取锁的过程中被中断，则会抛出 InterruptedException 异常。
超时等待式获取锁（tryAcquireNanos()方法）： ReentrantLock 类的 tryLock(long time, TimeUnit unit) 方法允许线程在指定的时间内尝试获取独占锁。如果在指定时间内获取到了锁，则返回 true，否则返回 false。

需要注意的是，在使用独占锁时，要遵循一定的规范，确保获取锁和释放锁的操作成对出现，防止出现死锁或资源泄漏等问题。

代码示例

以下是一个示例代码，展示了使用 ReentrantLock 实现独占锁（互斥锁）的方法，

import java.util.concurrent.locks.ReentrantLock;

public class main {
    private static ReentrantLock lock = new ReentrantLock(); // 创建一个 ReentrantLock 对象作为独占锁

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            try {
                lock.lock(); // 线程 1 获取独占锁
                System.out.println("线程 1 成功获取到了独占锁");
            } finally {
                lock.unlock(); // 线程 1 释放独占锁
                System.out.println("线程 1 成功释放了独占锁");
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                lock.lock(); // 线程 2 获取独占锁
                System.out.println("线程 2 成功获取到了独占锁");
            } finally {
                lock.unlock(); // 线程 2 释放独占锁
                System.out.println("线程 2 成功释放了独占锁");
            }
        });

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

在上面的示例中，我们创建了一个 ReentrantLock 对象作为独占锁，并实现了两个线程对该锁的获取和释放操作。其中，线程 t1 和 t2 都会使用 lock() 方法获取独占锁，执行完需要的操作后再使用 unlock() 方法释放锁。

值得注意的是，在获取独占锁的过程中，如果该锁已经被其他线程占用，则当前线程会被阻塞，直到锁可用时才会继续执行。另外，使用 try-finally 块来确保在获取锁后一定会在最终释放锁，以避免出现死锁或其他异常情况。

请注意，在实际开发中，应该根据具体情况设计和实现独占锁的逻辑，并考虑线程安全、性能和可扩展性等方面的问题。同时，也可以考虑使用其他类型的锁（如读写锁、乐观锁等）来提高程序的并发性能。

共享锁

Java提供了ReentrantReadWriteLock类来实现共享锁。这个类提供了一组方法来获取和释放共享锁，包括acquireShared()、releaseShared()、acquireSharedInterruptibly()和tryAcquireSharedNanos()。

1、共享锁的获取（acquireShared()方法）：acquireShared() 方法用于获取共享锁。当多个线程都需要访问共享资源时，可以使用该方法来获取读锁。

protected int tryAcquireShared(int arg) { ... }

在这个方法中，我们可以自定义获取共享锁的逻辑。当返回负数时，表示获取共享锁失败，线程需要阻塞等待；当返回0时，表示获取共享锁成功，但其他线程无法同时获取共享锁；当返回正数时，表示获取共享锁成功，并且其他线程可以继续获取共享锁。

注意：这个方法不是公开方法，而是在ReentrantReadWriteLock类内部使用，所以我们无法直接调用该方法。

2、共享锁的释放（releaseShared()方法）：releaseShared() 方法用于释放共享锁。当一个线程完成了对共享资源的读操作后，需要调用该方法来释放读锁。

protected boolean tryReleaseShared(int arg) { ... }

在这个方法中，我们可以自定义释放共享锁的逻辑。当返回true时，表示成功释放共享锁；当返回false时，表示释放共享锁失败。

注意：这个方法不是公开方法，而是在ReentrantReadWriteLock类内部使用，所以我们无法直接调用该方法。

3、可中断（acquireSharedInterruptibly()方法）：acquireSharedInterruptibly() 方法可用于获取可中断的共享锁。当调用该方法时，如果其他线程正在持有独占写锁，当前线程将被阻塞，直到获取到共享锁或线程被中断。

public void acquireSharedInterruptibly(int arg) throws InterruptedException { ... }

如果线程在等待获取共享锁期间被中断，则会抛出InterruptedException异常。

4、超时等待（tryAcquireSharedNanos()方法）：tryAcquireSharedNanos() 方法用于进行超时等待，即等待一段时间来获取共享锁。如果在指定的时间内没有获取到共享锁，则返回结果为负数。

public boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException { ... }

这个方法的第二个参数是等待的最大时间，单位为纳秒。如果线程在规定时间内获取到了共享锁，则返回true；如果等待超时仍未获取到共享锁，则返回false。

请注意，以上方法的具体实现需要根据具体的业务需求进行定义和实现。在使用共享锁时，应该遵循正确的加锁和释放锁的顺序，以避免死锁和资源争用等问题。同时，共享锁应该在多个线程之间保持同步，确保数据的一致性和线程安全性。

代码示例

import java.util.concurrent.locks.ReentrantReadWriteLock;

public class main {
    private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static String data = "Hello, world!";

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            Thread readerThread = new Thread(new Reader(), "Reader " + (i + 1));
            readerThread.start();
        }
        Thread writerThread = new Thread(new Writer(), "Writer");
        writerThread.start();
    }

    static class Reader implements Runnable {
        @Override
        public void run() {
            lock.readLock().lock(); // 获取读锁
            try {
                System.out.println(Thread.currentThread().getName() + ": 正在读取数据：" + data);
                Thread.sleep(1000); // 模拟读取操作耗时
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                e.printStackTrace();
            } finally {
                lock.readLock().unlock(); // 释放读锁
            }
        }
    }

    static class Writer implements Runnable {
        @Override
        public void run() {
            lock.writeLock().lock(); // 获取写锁
            try {
                System.out.println(Thread.currentThread().getName() + ": 正在写入数据...");
                data = data.toUpperCase(); // 修改数据
                Thread.sleep(1000); // 模拟写入操作耗时
                System.out.println(Thread.currentThread().getName() + ": 数据写入完成");
                System.out.println(Thread.currentThread().getName() + ": 新的数据为: "+ data);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                e.printStackTrace();
            } finally {
                lock.writeLock().unlock(); // 释放写锁
            }
        }
    }
}

在这个示例中，ReentrantReadWriteLock类提供了读锁和写锁。读锁是共享锁，多个线程可以同时获取；写锁是独占锁，只能由一个线程获取。

在Reader类的run()方法中，线程首先获取读锁，然后进行读取操作，并输出读取的数据，最后释放读锁。

在Writer类的run()方法中，线程首先获取写锁，然后进行写入操作，将数据转换成大写形式，模拟写入操作耗时，最后释放写锁。

运行示例时，5个Reader线程将同时获取读锁，读取共享资源中的数据（字符串 "Hello, world!"），并输出读取的数据。在此期间，Writer线程将尝试获取写锁，但由于有读锁保持着，写锁会被阻塞，直到所有读锁都被释放。一旦写锁获取成功，Writer线程将修改共享资源的数据，将它转换为大写形式，并模拟写入操作耗时。最后，Writer线程释放写锁。

请注意：这个示例只是展示了共享锁的一种使用方式，并不涉及具体的业务场景。在实际应用中，需要根据具体的需求和线程安全性要求来设计和使用共享锁。同时，要注意避免死锁和数据一致性问题，确保正确获取和释放锁。

正在奋斗的程序猿

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java进阶篇--AQS(AbstractQueuedSynchronizer)

"），并输出读取的数据。在上面的示例中，我们创建了一个 ReentrantLock 对象作为独占锁，并实现了两个线程对该锁的获取和释放操作。AQS的核心思想是使用一个整形的state值来表示同步状态，state的语义由具体的同步器决定，可以表示锁的可重入次数、资源的数量等。值得注意的是，在获取独占锁的过程中，如果该锁已经被其他线程占用，则当前线程会被阻塞，直到锁可用时才会继续执行。请注意，在实际开发中，应该根据具体情况设计和实现独占锁的逻辑，并考虑线程安全、性能和可扩展性等方面的问题。
复制链接

扫一扫