03.并发多线程AQS

AQS是什么

• 全称是AbstractQueuedSynchronizer,（抽象队列同步器）
• 它的定位手机为java中几乎所有的锁和同步器提供一个基础框架
• AQS是基于FIFO的队列（First-In，First-Out，先进先出）实现的，并且内部维护了一个状态变量state，通过原子(CAS)更新这个状态变量即可以实现加锁解锁的操作

AQS的实现原理

思想

如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效工作线程，并且将共享资源设置为锁定状态，如果被请求的共享资源被占用，那么就需要一套线程阻塞等待以及被唤醒是锁分配的机制，这个机制AQS是用CLH队列锁实现的，将即将暂时获取不到锁的线程加入到队列中。

CLH队列

CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列（虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系）。AQS是将每条请求共享资源的线程封装成一个CLH队列的一个结点来实现锁的分配

核心源码的分析

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;


    /**
     * Creates a new {@code AbstractQueuedSynchronizer} instance
     * with initial synchronization state of zero.
     */
    protected AbstractQueuedSynchronizer() { }
    
     static final class Node {
        // 标识一个节点是共享模式
        static final Node SHARED = new Node();
        // 标识一个节点是互斥模式
        static final Node EXCLUSIVE = null;
    
        // 标识线程已取消
        static final int CANCELLED =  1;
        // 标识后继节点需要唤醒
        static final int SIGNAL    = -1;
        // 标识线程等待在一个条件上
        static final int CONDITION = -2;
        // 标识后面的共享锁需要无条件的传播（共享锁需要连续唤醒读的线程）
        static final int PROPAGATE = -3;
        
        // 当前节点保存的线程对应的等待状态
        volatile int waitStatus;
    
        // 前一个节点
        volatile Node prev;
        
        // 后一个节点
        volatile Node next;
    
        // 当前节点保存的线程
        volatile Thread thread;
    
        // 下一个等待在条件上的节点（Condition锁时使用）
        Node nextWaiter;
    
        // 是否是共享模式
        final boolean isShared() {
            return nextWaiter == SHARED;
        }
    
        // 获取前一个节点
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
    
        // 节点的构造方法
        Node() {    // Used to establish initial head or SHARED marker
        }
    
        // 节点的构造方法
        Node(Thread thread, Node mode) {     // Used by addWaiter
            // 把共享模式还是互斥模式存储到nextWaiter这个字段里面了
            this.nextWaiter = mode;
            this.thread = thread;
        }
    
        // 节点的构造方法
        Node(Thread thread, int waitStatus) { // Used by Condition
            // 等待的状态，在Condition中使用
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

}   
    

AQS底层使用了模板方法模式

同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样的

• 使用者继承AbstractQueuedSynchronizer并重写指定的方法（这些重写方法很简单，无非是对于贡献资源state的获取和释放）
• 将AQS组合在自定义同步组件的实现中，并调用其模板方法，而这些模板方法会调用使用者重写的方法

自定义AQS的时候需要重写一下的几个方法

1. isHeldExclusively()//该线程是否正在独占资源。只有用到condition才需要去实现它。
2. tryAcquire(int)//独占方式。尝试获取资源，成功则返回true，失败则返回false。
3. tryRelease(int)//独占方式。尝试释放资源，成功则返回true，失败则返回false。
4. tryAcquireShared(int)//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
5. tryReleaseShared(int)//共享方式。尝试释放资源，成功则返回true，失败则返回false。