AQS(一) 对CLH队列的增强

基本概念

AQS(AbstractQueuedSynchronizer),顾名思义,是一个抽象的队列同步器。

  1. 它的队列是先进先出(FIFO)的等待队列
  2. 基于这个队列,AQS提供了一个实现阻塞锁的机制
  3. 最终,基于这个阻塞锁,可以实现多线程的同步

先进先出的等待队列

这个等待队列,是基于CLH锁实现的。
CLH锁是以发明人命名的自旋锁,这个锁是一个基于队列的自旋锁,是对SpinLock,TicketLock的进化。
具体可以参考另外一篇文章,最好是可以自己实现下。

CLH锁的基本原理:

  1. 使用FIFO队列保证公平性
  2. 有当前节点和前置节点,当前节点不断自旋,查询(监听)前置节点的状态(isLocked)(保证了FIFO)
  3. 一系列的前置节点和当前节点构成队列
  4. 当前节点运行完成后,更改自己的状态,那监听当前节点状态的线程就会结束自旋

CLH锁,使用了一个属性tail(尾节点)来关联前置节点和当前节点
lock时:

  1. 新建节点并与当前线程绑定(使用ThreadLocal)
  2. 获取原有的尾节点作为前置节点,设置尾节点为当前节点(这样其他节点就可以挂在当前节点后)
    //说明有前置节点
    if(原尾节点不为空){
        //自旋以等待前置节点状态改变
    }

unlock时:

  1. 把当前节点的isLock状态置为false.
  2. (下一个节点的)监听当前节点状态的自旋被解除

总结:
当前节点不断自旋访问前置节点的状态,状态改变时结束自旋

AQS对CLH的增强和进化

AQS基于CLH锁的访问前置节点信息的原理实现,并添加了一些功能:

  1. 支持阻塞而不是一直自旋,竞争激烈时,阻塞性能更好
  2. 支持可重入
  3. 支持取消节点
  4. 支持中断
  5. 支持独占(互斥)和共享两种模式
  6. 支持Condition Condition替代对象监听器(Monitor)用来等待,唤醒线程,用于线程间的协作

AQS基于对CLH的改进提供了实现同步器的机制,解决了获取锁失败后的问题,
子类仅仅需要实现获取/释放锁的具体逻辑。该机制包括:

  1. AQS不关注怎么获取锁/释放锁(如何获取和释放锁,由具体子类实现)。
    //获取锁的逻辑,成功返回true
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }
    //释放锁,完全释放(考虑重入)返回true
    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }
    //共享模式获取锁
    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }
    //共享模式释放锁
    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }
  1. AQS关注的是获取失败后:
    2.1 构建CLH队列
    2.2 不断自旋
    2.2.1 检查前置节点是否是头节点(头节点是持有锁的节点),如果是头节点,则尝试获取锁,获取成功,线程持有锁,否则走下面
    2.2.2 检查前置节点的状态,如果不是等待唤醒(SIGNAL),就把前置节点设置为SIGNAL,否则把当前节点的线程阻塞,
    也就是说,第二次循环时,当前节点就被阻塞了。
    2.2.3 线程被唤醒后,会继续执行2.2.1,得到获取锁的机会
            /**
                入口:获取锁,失败就阻塞
             * Acquires in exclusive mode, ignoring interrupts.  Implemented
             * by invoking at least once {@link #tryAcquire},
             * returning on success.  Otherwise the thread is queued, possibly
             * repeatedly blocking and unblocking, invoking {@link
             * #tryAcquire} until success.  This method can be used
             * to implement method {@link Lock#lock}.
             *
             * @param arg the acquire argument.  This value is conveyed to
             *        {@link #tryAcquire} but is otherwise uninterpreted and
             *        can represent anything you like.
             */
            public final void acquire(int arg) {
                if (!tryAcquire(arg) &&
                    acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
                    selfInterrupt();
            }

            /**
             * 构建了一个队列 对应2.1

             1.入队:原子性的更新tail
             2.出队:更新head

             *        +------+  prev +-----+       +-----+
                 head |      | <---- |     | <---- |     |  tail
                      +------+       +-----+       +-----+
             * Creates and enqueues node for current thread and given mode.
             *
             * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
             * @return the new node
             */
            private Node addWaiter(Node mode) {
                Node node = new Node(Thread.currentThread(), mode);
                // Try the fast path of enq; backup to full enq on failure
                Node pred = tail;
                if (pred != null) {
                    node.prev = pred;
                    if (compareAndSetTail(pred, node)) {
                        pred.next = node;
                        return node;
                    }
                }
                enq(node);
                return node;
            }
            /**
                自旋至阻塞的过程:对应2.2
             * Acquires in exclusive uninterruptible mode for thread already in
             * queue. Used by condition wait methods as well as acquire.
             *
             * @param node the node
             * @param arg the acquire argument
             * @return {@code true} if interrupted while waiting
             */
            final boolean acquireQueued(final Node node, int arg) {
                boolean failed = true;
                try {
                    boolean interrupted = false;
                    for (;;) {
                        //检查头节点,对应2.2.1
                        final Node p = node.predecessor();
                        if (p == head && tryAcquire(arg)) {
                            setHead(node);
                            p.next = null; // help GC
                            failed = false;
                            return interrupted;
                        }
                        //判断前置节点的状态,并阻塞当前节点对应的线程 对应2.2.2
                        if (shouldParkAfterFailedAcquire(p, node) &&
                            parkAndCheckInterrupt())
                            interrupted = true;
                    }
                } finally {
                    if (failed)
                        cancelAcquire(node);
                }
            }
  1. 释放锁成功后:
    3.1 拿到头节点的下一个节点
    3.2 唤醒这个节点
    3.3 被唤醒的节点走到2.2.3 然后走2.2.1
    /**
    释放锁的入口:成功后唤醒下一个节点
     * Releases in exclusive mode.  Implemented by unblocking one or
     * more threads if {@link #tryRelease} returns true.
     * This method can be used to implement method {@link Lock#unlock}.
     *
     * @param arg the release argument.  This value is conveyed to
     *        {@link #tryRelease} but is otherwise uninterpreted and
     *        can represent anything you like.
     * @return the value returned from {@link #tryRelease}
     */
    public final boolean release(int arg) {
        if (tryRelease(arg)) {
            //对应3.1
            Node h = head;
            if (h != null && h.waitStatus != 0)
                //对应3.2,唤醒之后,下一个节点结束阻塞,自旋获取锁进入2.2.1
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

小结:

从整个锁的获取和释放的流程来看,其基本的原理与CLH锁并没有太大区别:

1.尝试获取锁,失败则进入队列,然后自旋检查前置节点的状态
2.释放锁,同时保证某个后置节点能获取到锁并结束自旋

你可能感兴趣的:(并发编程,精华,Java多线程全解密)