队列同步器（AbstractQueuedSynchronizer）（一）

电玩女神 2022-02-26 00:06 210阅读 0赞

**队列同步器AbstractQueuedSynchronizer是用来构建锁或者其他同步组件的基础框架，它使用了一个int成员变量表示同步状态，通过内置的FIFO队列来完成资源获取线程的排队工作。**

## **队列同步器的接口** ##

**    同步器的设计是基于模板方法模式的，也就是说，使用者需要继承同步器并重写指定的方法，随后将同步器组合在自定义同步组件的实现中，并调用同步器提供的模板方法，而这些模板方法将会调用使用者重写的方法。**

重写同步器指定的方法时，需要使用同步器提供的如下3个方法来访问或修改同步状态。

/**
         * Returns the current value of synchronization state.
         * This operation has memory semantics of a {@code volatile} read.
         * @return current state value
         */
        protected final int getState() {
            return state;
        }
    
        /**
         * Sets the value of synchronization state.
         * This operation has memory semantics of a {@code volatile} write.
         * @param newState the new state value
         */
        protected final void setState(int newState) {
            state = newState;
        }
    
        /**
         * Atomically sets synchronization state to the given updated
         * value if the current state value equals the expected value.
         * This operation has memory semantics of a {@code volatile} read
         * and write.
         *
         * @param expect the expected value
         * @param update the new value
         * @return {@code true} if successful. False return indicates that the actual
         *         value was not equal to the expected value.
         */
        protected final boolean compareAndSetState(int expect, int update) {
            // See below for intrinsics setup to support this
            return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
        }

同步器可重写的方法：

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:313px;"> 方法名称 </td> 
 <td style="vertical-align:top;width:535px;"> 描&nbsp; 述 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:313px;"> protected boolean tryAcquire(int arg) </td> 
 <td style="vertical-align:top;width:535px;"> 独占式地获取同步状态，实现该方法需要查询当前状态并判断当前状态是否符合预期，然后再进行CAS设置同步状态&nbsp; </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:313px;"> protected boolean tryRelease(int arg) </td> 
 <td style="vertical-align:top;width:535px;"> 独占式释放同步状态，等待获取同步状态的线程将有机会获取同步状态 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:313px;"> protected int tryAcquireShared(int arg) </td> 
 <td style="vertical-align:top;width:535px;"> 共享式获取同步状态，返回大于等于0的值，表示获取成功，反之，获取失败 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:313px;"> protected boolean tryReleaseShared(int arg) </td> 
 <td style="vertical-align:top;width:535px;"> 共享式释放同步状态 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:313px;"> protected boolean isHeldExclusively() </td> 
 <td style="vertical-align:top;width:535px;"> 当前同步器是否在独占模式下被线程占用，一般该方法表示是否被当前线程所独占 </td> 
 </tr> 
 </tbody> 
</table>

实现自定义同步组件时，将会调用同步器提供的模板方法，部分模板方法与描述如下：

<table> 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> 方法名称 </td> 
 <td style="vertical-align:top;width:563px;"> 描&nbsp; 述 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> void acquire(int arg) </td> 
 <td style="vertical-align:top;width:563px;"> 独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法将会调用可重写的tryAcquire(int arg)方法 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> void acquireInterruptibly(int arg) </td> 
 <td style="vertical-align:top;width:563px;"> 与acquire(int arg)相同，但是该方法响应中断，当前线程为获取到同步状态而进入到同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException异常并返回 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> boolean tryAcquireNanos(int arg,long nanos) </td> 
 <td style="vertical-align:top;width:563px;"> 在acquireInterruptibly(int arg)基础上增加超时限制 ，如果当前线程在超时时间内没有获取到同步状态，那么将会返回false，已经获取则返回true </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> void acquireShared(int arg) </td> 
 <td style="vertical-align:top;width:563px;"> 共享式获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式的主要区别是在同一时刻可以有多个线程获取到同步状态 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> void acquireSharedInterruptibly(int arg) </td> 
 <td style="vertical-align:top;width:563px;"> 与acquireShared(int arg)相同，该方法响应中断 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> boolean tryAcquireSharedNanos(int arg, long nanosTimeout) </td> 
 <td style="vertical-align:top;width:563px;"> 在acquireSharedInterruptibly(int arg)的基础上，增加了超时限制 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> boolean release(int arg) </td> 
 <td style="vertical-align:top;width:563px;"> 独占式释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> Boolean releaseShared(int arg) </td> 
 <td style="vertical-align:top;width:563px;"> 共享式释放同步状态 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:285px;"> Collection&lt;Thread&gt; getQueuedThreads() </td> 
 <td style="vertical-align:top;width:563px;"> 获取等待在同步队列上的线程集合 </td> 
 </tr> 
 </tbody> 
</table>

**同步器提供的模板方法基本上分为三类：独占式获取与释放同步状态、共享式获取与释放同步状态和查询同步队列中的等待线程情况，自定义同步组件将使用同步器提供的模板方法来实现自己的同步语义。 **

## **队列同步器的实现** ##

### 1.同步队列 ###

**    同步器依赖内部的同步队列（一个FIFO双向队列）来完成同步状态的管理，当前线程获取同步状态失败时，同步器会将当前线程以及等待状态等信息构造成为一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点中的线程唤醒，使其再次尝试获取同步状态**

static final class Node {
            /** Marker to indicate a node is waiting in shared mode */
            static final Node SHARED = new Node();
            /** Marker to indicate a node is waiting in exclusive mode */
            static final Node EXCLUSIVE = null;
    
            /** waitStatus value to indicate thread has cancelled */
            static final int CANCELLED =  1;
            /** waitStatus value to indicate successor's thread needs unparking */
            static final int SIGNAL    = -1;
            /** waitStatus value to indicate thread is waiting on condition */
            static final int CONDITION = -2;
            /**
             * waitStatus value to indicate the next acquireShared should
             * unconditionally propagate
             */
            static final int PROPAGATE = -3;
    
            /**
             * Status field, taking on only the values:
             *   SIGNAL:     The successor of this node is (or will soon be)
             *               blocked (via park), so the current node must
             *               unpark its successor when it releases or
             *               cancels. To avoid races, acquire methods must
             *               first indicate they need a signal,
             *               then retry the atomic acquire, and then,
             *               on failure, block.
             *   CANCELLED:  This node is cancelled due to timeout or interrupt.
             *               Nodes never leave this state. In particular,
             *               a thread with cancelled node never again blocks.
             *   CONDITION:  This node is currently on a condition queue.
             *               It will not be used as a sync queue node
             *               until transferred, at which time the status
             *               will be set to 0. (Use of this value here has
             *               nothing to do with the other uses of the
             *               field, but simplifies mechanics.)
             *   PROPAGATE:  A releaseShared should be propagated to other
             *               nodes. This is set (for head node only) in
             *               doReleaseShared to ensure propagation
             *               continues, even if other operations have
             *               since intervened.
             *   0:          None of the above
             *
             * The values are arranged numerically to simplify use.
             * Non-negative values mean that a node doesn't need to
             * signal. So, most code doesn't need to check for particular
             * values, just for sign.
             *
             * The field is initialized to 0 for normal sync nodes, and
             * CONDITION for condition nodes.  It is modified using CAS
             * (or when possible, unconditional volatile writes).
             */
            volatile int waitStatus;
    
            /**
             * Link to predecessor node that current node/thread relies on
             * for checking waitStatus. Assigned during enqueuing, and nulled
             * out (for sake of GC) only upon dequeuing.  Also, upon
             * cancellation of a predecessor, we short-circuit while
             * finding a non-cancelled one, which will always exist
             * because the head node is never cancelled: A node becomes
             * head only as a result of successful acquire. A
             * cancelled thread never succeeds in acquiring, and a thread only
             * cancels itself, not any other node.
             */
            volatile Node prev;
    
            /**
             * Link to the successor node that the current node/thread
             * unparks upon release. Assigned during enqueuing, adjusted
             * when bypassing cancelled predecessors, and nulled out (for
             * sake of GC) when dequeued.  The enq operation does not
             * assign next field of a predecessor until after attachment,
             * so seeing a null next field does not necessarily mean that
             * node is at end of queue. However, if a next field appears
             * to be null, we can scan prev's from the tail to
             * double-check.  The next field of cancelled nodes is set to
             * point to the node itself instead of null, to make life
             * easier for isOnSyncQueue.
             */
            volatile Node next;
    
            /**
             * The thread that enqueued this node.  Initialized on
             * construction and nulled out after use.
             */
            volatile Thread thread;
    
            /**
             * Link to next node waiting on condition, or the special
             * value SHARED.  Because condition queues are accessed only
             * when holding in exclusive mode, we just need a simple
             * linked queue to hold nodes while they are waiting on
             * conditions. They are then transferred to the queue to
             * re-acquire. And because conditions can only be exclusive,
             * we save a field by using special value to indicate shared
             * mode.
             */
            Node nextWaiter;
    
            /**
             * Returns true if node is waiting in shared mode.
             */
            final boolean isShared() {
                return nextWaiter == SHARED;
            }
    
            /**
             * Returns previous node, or throws NullPointerException if null.
             * Use when predecessor cannot be null.  The null check could
             * be elided, but is present to help the VM.
             *
             * @return the predecessor of this node
             */
            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
                this.nextWaiter = mode;
                this.thread = thread;
            }
    
            Node(Thread thread, int waitStatus) { // Used by Condition
                this.waitStatus = waitStatus;
                this.thread = thread;
            }
        }

<table> 节点的属性类型与名称以及描述 
 <tbody> 
 <tr> 
 <td style="vertical-align:top;width:205px;"> 属性类型与名称 </td> 
 <td style="vertical-align:top;width:643px;"> 描&nbsp; 述 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:205px;"> Node SHARED </td> 
 <td style="vertical-align:top;width:643px;"> 表示节点使用共享模式等待 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;width:205px;"> Node EXCLUSIVE </td> 
 <td style="vertical-align:top;width:643px;"> 表示节点使用独占模式等待 </td> 
 </tr> 
 <tr> 
 <td style="width:205px;"> nt waitStatus </td> 
 <td style="vertical-align:top;width:643px;"> 等待状态，包含如下几个状态： 
 <ol> 
 <li>CANCELLED，值为1，由于在同步队列中等待的线程等待超时或者被中断，该节点不会参与</li> 
 <li>同步状态的竞争，需要从同步队列中取消等待，节点进入该状态后将不会再变化；</li> 
 <li>SIGNAL，值为-1，后继节点的线程处于等待状态，而当前节点的线程如果释放了同步状态或者被取消，将会通知后继节点，使后继节点的线程得以运行； &nbsp;</li> 
 <li>CONDITION，值为-2，节点在等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了signal()方法后，该节点将会从等待队列中转移到同步队列中，加入到同步状态的获取中；</li> 
 <li>PROPAGATE，值为-3，表示下一次共享式同步状态获取将会无条件地传播下去；</li> 
 <li>INITIAL，值为0，初始状态</li> 
 </ol></td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> Node prev </td> 
 <td style="vertical-align:top;"> 前驱节点，当节点加入同步队列时被设置（尾部添加） </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> Node next </td> 
 <td style="vertical-align:top;"> 后继节点 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> Node nextWaiter </td> 
 <td style="vertical-align:top;"> 等待队列中的后继节点。如果当前节点是共享的，那么这个字段将是一个SHARED常量，也就是说节点类型 （独占和共享）和等待队列中的后继节点公用同一个字段 </td> 
 </tr> 
 <tr> 
 <td style="vertical-align:top;"> Thread thread </td> 
 <td style="vertical-align:top;"> 获取同步状态的线程 </td> 
 </tr> 
 </tbody> 
</table>

节点是构成同步队列的基础，同步器拥有首节点（head） 和尾节点（tail），没有成功获取同步状态的线程将会成为节点加入该队列的尾部。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70][]

**同步器包含了两个节点类型的引用，一个指向头节点，而另一个指向尾节点。**  
    当一个线程成功地获取了同步状态（或者锁），其他线程将无法获取到同步状态，转而被构造成为节点并加入到同步队列中，而这个加入队列的过程必须要保证线程安全，因此同步器提供了一个基于CAS的设置尾节点的方法：**compareAndSetTail(Node expect,Node update)**，它需要传递当前线程“认为”的尾节点和当前节点，只有设置成功后，当前节点才正式与之前的尾节点建立关联。

/**
         * CAS tail field. Used only by enq.
         */
        private final boolean compareAndSetTail(Node expect, Node update) {
            return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
        }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 1][]

**同步队列遵循FIFO，首节点是获取同步状态成功的节点，首节点的线程在释放同步状态时，将会唤醒后继节点，而后继节点将会在获取同步状态成功时将自己设置为首节点。**

**![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 2][]**

**    设置首节点是通过获取同步状态成功的线程来完成的，由于只有一个线程能够成功获取到同步状态，因此设置头节点的方法并不需要使用CAS来保证，它只需要将首节 点设置成为原首节点的后继节点并断开原首节点的next引用即可。**

参考《Java并发编程的艺术》

CSDN连接：[https://download.csdn.net/download/qq\_37598011/11068576][https_download.csdn.net_download_qq_37598011_11068576]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70]: /images/20220226/2755d116397347fcbd827abc12bdcd2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 1]: /images/20220226/b8e4db2bc4fe4ffbb9ef4c8475278713.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NTk4MDEx_size_16_color_FFFFFF_t_70 2]: /images/20220226/e004dc63313549a7a44f677f30423bfb.png
[https_download.csdn.net_download_qq_37598011_11068576]: https://download.csdn.net/download/qq_37598011/11068576