AQS（AbstractQueuedSynchronizer）同步器

队列同步器AbstractQueuedSynchronizer（以下简称同步器或 AQS），是用

来构建锁或者其他同步组件的基础框架，它使用了一个 int 成员变量表示同步状

态，通过内置的 FIFO 队列来完成资源获取线程的排队工作。并发包的大师（Doug

Lea）期望它能够成为实现大部分同步需求的基础。

AQS使用方式和其中的设计模式

AQS是主要使用方式是继承，子类通过继承AQS并实现它的抽象方法来管理同步状态，在AQS里面有一个int型的state来代表这个状态，在抽象方法的实现过程中免不了要对同步状态进行更改，这时就需要使用同步器提供的3个方法：getState()、setState(int newState)、compareAndSetState(int expect,int update)来进行操作，因为它们能够保证状态的改变是安全的。

private volatile int state;

protected final int getState() {
        return state;
    }

protected final void setState(int newState) {
        state = newState;
    }

protected final boolean compareAndSetState(int expect, int update) {
        return U.compareAndSwapInt(this, STATE, expect, update);
    }

举例：

class Mutex implements Lock, java.io.Serializable {

   // Our internal helper class
   private static class Sync extends AbstractQueuedSynchronizer {
     // Reports whether in locked state
     protected boolean isHeldExclusively() {
       return getState() == 1;
     }

     // Acquires the lock if state is zero
     public boolean tryAcquire(int acquires) {
       assert acquires == 1; // Otherwise unused
       if (compareAndSetState(0, 1)) {
         setExclusiveOwnerThread(Thread.currentThread());
         return true;
       }
       return false;
     }

     // Releases the lock by setting state to zero
     protected boolean tryRelease(int releases) {
       assert releases == 1; // Otherwise unused
       if (getState() == 0) throw new IllegalMonitorStateException();
       setExclusiveOwnerThread(null);
       setState(0);
       return true;
     }

     // Provides a Condition
     Condition newCondition() { return new ConditionObject(); }

     // Deserializes properly
     private void readObject(ObjectInputStream s)
         throws IOException, ClassNotFoundException {
       s.defaultReadObject();
       setState(0); // reset to unlocked state
     }
   }

设计模式就是模板方法模式，比如Android中的BaseActivity。具体不讲了。

CLH队列锁

        CLH队列也是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程 

仅仅在本地变量上自旋，它不断轮询前驱的状态，假设发现前驱释放了锁就结束 

自旋。

        QNode：就是说把我们正在阻塞排队的每一个线程进行打包成一个节点，节点里面有：线程本身、myPre指向前一个节点的引用、locked=TRUE表示要获取锁。

假如线程A目前获取到锁了，现在线程A释放了锁，线程B要变成获取锁的状态的话：

 

线程A这个节点的locked就变为false了，此时B获取到锁。 

ReentrantLock的实现

锁的可重入：

        重入是指任意线程在获取到锁后能够再次获取到该锁而不会被锁所阻塞，该特性的实现需要解决以下两个问题：

        1、线程再次获取锁，。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取。

        2、锁的最终释放。线程重复n次获取了锁，随后在第N次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求对于获取进行计数自增，计数标识当前锁被重复获取的次数，而锁被释放是，计数自减，当计数=0时标识锁已经冲个释放。

公平锁和非公平锁：

        

        ReentrantLock 的构造函数中，默认的无参构造函数将会把 Sync 对象创建为 NonfairSync 对象，这是一个“非公平锁”；而另一个构造函数 ReentrantLock(boolean fair)传入参数为 true 时将会把 Sync 对象创建为“公平锁” FairSync。     

        nonfairTryAcquire(int acquires)方法，对于非公平锁，只要 CAS 设置同步状态 成功，则表示当前线程获取了锁，而公平锁则不同。tryAcquire 方法，该方法与 nonfairTryAcquire(int acquires)比较，唯一不同的位置为判断条件多了 hasQueuedPredecessors()方法，即加入了同步队列中当前节点是否有前驱节点的 判断，如果该方法返回 true，则表示有线程比当前线程更早地请求获取锁，因此 需要等待前驱线程获取并释放锁之后才能继续获取锁。

其实说到底就是阻塞时，会不会排序等待

公平锁：像这种排队的

        

 非公平锁（插队）：