Java多线程之AbstractQueuedSynchronizer

2018年03月31日 再理解AQS队列同步器
https://blog.csdn.net/kevin_king1992/article/details/79813078
https://my.oschina.net/wugong/blog/1784946

---

2017年06月18日

参考：JDK 1.6.0 API 中文版
参考：JDK 1.8.0_121
参考：http://www.jianshu.com/p/ac0fb814e1a3
参考：http://www.jianshu.com/p/791981de7579
感谢作者。

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

}

由上面可以看出AbstractQueuedSynchronizer是一个继承了AbstractOwnableSynchronizer的抽象类。
那么AbstractOwnableSynchronizer又是什么呢？AbstractOwnableSynchronizer是可以由线程以独占方式拥有的同步器。
AbstractOwnableSynchronizer源码如下：

public abstract class AbstractOwnableSynchronizer implements java.io.Serializable { 
    //供子类使用的空构造方法 
    protected AbstractOwnableSynchronizer() { } 
    private transient Thread exclusiveOwnerThread; 
    //设置当前拥有独占访问的线程。
    protected final void setExclusiveOwnerThread(Thread thread){ 
        exclusiveOwnerThread = thread; 
    } 
    //返回由 setExclusiveOwnerThread 最后设置的线程；如果从未设置，则返回 null。
    protected final Thread getExclusiveOwnerThread() { return exclusiveOwnerThread; }
    }

关于transient文章：http://www.cnblogs.com/liuling/archive/2013/05/05/transient.html

在AbstractQueuedSynchronizer源码中，有一个静态的内部类Node，

AQS通过内置的FIFO同步队列来完成资源获取线程的排队工作，如果当前线程获取同步状态失败（锁）时，AQS则会将当前线程以及等待状态等信息构造成一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，则会把节点中的线程唤醒，使其再次尝试获取同步状态。（引自：http://www.jianshu.com/p/ac0fb814e1a3）

：

static final class Node {
        /** 共享node */
        static final Node SHARED = new Node();
        /** 独享node */
        static final Node EXCLUSIVE = null;

        //以下为waitStatus的状态常量表示
        /** 取消状态 */
        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;
        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() { // 被用于创建初始的头结点或共享创建者
        }

        Node(Thread thread, Node mode) { // 被用于添加等待者
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { //被用于 条件Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }
    }

头结点，懒加载：
private transient volatile Node head;
尾结点，同样也是懒加载，
private transient volatile Node tail;
同步状态：
private volatile int state;
当state>0的时候获取锁，当state=0的时候释放锁。
通过getState()和setState(int newState)、compareAndSetState(int expect, int update)进行 state状态变量的获取和设置。

AQS主要提供了如下一些方法：

• getState()：返回同步状态的当前值； setState(int newState)：设置当前同步状态；
• compareAndSetState(int expect, int
• update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性； tryAcquire(int
• arg)：独占式获取同步状态，获取同步状态成功后，其他线程需要等待该线程释放同步状态才能获取同步状态； tryRelease(int
• arg)：独占式释放同步状态； tryAcquireShared(int
• arg)：共享式获取同步状态，返回值大于等于0则表示获取成功，否则获取失败；
• tryReleaseShared(int arg)：共享式释放同步状态；
• isHeldExclusively()：当前同步器是否在独占式模式下被线程占用，一般该方法表示是否被当前线程所独占；
• acquire(int arg)：独占式获取同步状态，如果当前线程获取同步状态成功，则由该方法返回，否则，将会进入同步队列等待，该方法将会调用可重写的tryAcquire(int
  arg)方法；
• acquireInterruptibly(int arg)：与acquire(int arg)相同，但是该方法响应中断，当前线程为获取到同步状态而进入到同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException异常并返回；
• tryAcquireNanos(int arg,long nanos)：超时获取同步状态，如果当前线程在nanos时间内没有获取到同步状态，那么将会返回false，已经获取则返回true；
• acquireShared(int arg)：共享式获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式的主要区别是在同一时刻可以有多个线程获取到同步状态；
• acquireSharedInterruptibly(int arg)：共享式获取同步状态，响应中断；
• tryAcquireSharedNanos(int arg, long nanosTimeout)：共享式获取同步状态，增加超时限制；
• release(int arg)：独占式释放同步状态，该方法会在释放同步状态之后，将同步队列中第一个节点包含的线程唤醒；
• releaseShared(int arg)：共享式释放同步状态；
  摘自：http://www.jianshu.com/p/ac0fb814e1a3