一文带你深入理解AQS

　　AQS
　　队列同步器AbstractQueuedSynchronizer，用来构建锁或者其他同步组件的基础框架，内部使用一个变量state来表示同步状态，同时使用一个FIFO队列来完成线程的排队工作。
　　锁或者其他同步组件一般都会定义一个静态内部类，该静态内部类会继承AQS，同时  重写  AQS中的方法，重写AQS中的方法时需要用到下面三个方法来获取同步状态。  getState()
　　获取state属性的内容。  setState(int newState)
　　设置state属性的内容。  compareAndSetState(int expect, int update)
　　使用CAS设置当前状态，保证状态设置的原子性。
　　总结：如何自定义一个锁或者同步组件？
　　创建静态内部类继承AQS，重写AQS中的  可重写  的方法，在里面使用AQS提供的如上三个方法来获取、修改同步状态。最后调用AQS中的模板方法来进行操作，模板方法中会调用重写的方法。
　　即使用者调用模板方法，模板方法调用重写方法，重写方法调用如上三个方法。
　　可重写的方法
　　protected boolean tryAcquire(int arg);
　　独占式获取 同步状态，查询当前状态并根据具体条件设置同步状态。
　　protected boolean tryRelease(int arg);
　　独占式释放 同步状态，等待的线程有机会获取同步状态。
　　protected int tryAcquireShared(int arg);
　　共享式获取 同步状态，返回大于等于0的值表示获取成功，反之获取失败。
　　4. protected boolean tryReleaseShared(int arg);
　　共享式释放 同步状态。
　　5. protected boolean isHeldExclusively();
　　表示是否被当前线程占用。 模板方法独占式获取同步状态
　　当前线程获取成功则会返回，否则进入同步队列 等待 ，调用重写方法中的 tryAcquire 。
　　2. 独占式获取同步状态，响应中断 void acquireInterruptible(int arg);
　　如果当前线程被中断，则会抛出InterruptedException。 超时获取同步状态 boolean tryAcquireNanos(int arg, long nanos);
　　在acquireInterruptible的基础上设置超时时间，如果超时时间还没有获取到同步状态，会返回false，否则返回true。 4. 共享获取同步状态 void acquireShared(int arg); 共享获取同步状态，响应中断 void acquireSharedInterruptible(int arg); 共享获取同步状态，响应中断，添加超时时间 boolean tryAcquireSharedNanos(int arg, long nanos); 独占式释放同步状态 boolean release(int arg);
　　同步队列中的第一个节点将会被唤醒。 8. 共享式释放同步状态 boolean releaseShared(int arg); 获取等待在同步队列上的线程集合 Collection getQueuedThreads();
　　总之：模板可以分为三类：独占式获取与释放同步状态、共享式获取与释放同步状态、查询同步队列线程等待情况。获取又有分为中断、超时。 自定义同步组件 public class UnReetrantLock implements Lock {           public static class Sync extends AbstractQueuedSynchronizer {                  @Override         protected boolean tryAcquire(int arg) {             if (compareAndSetState(0, 1)) {                                                     setExclusiveOwnerThread(Thread.currentThread());                 return true;             }             return false;         }                   @Override         protected boolean tryRelease(int arg) {                          setExclusiveOwnerThread(null);             setState(0);                 return false;         }          @Override         protected boolean isHeldExclusively() {             return getState() == 1;         }          public Condition newCondition() {             return new ConditionObject();         }      }      private Sync sync = new Sync();      @Override     public void lock() {         sync.acquire(1);     }      @Override     public void lockInterruptibly() throws InterruptedException {         sync.acquireInterruptibly(1);     }      @Override     public boolean tryLock() {         return sync.tryAcquire(1);     }      @Override     public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {         return sync.tryAcquireNanos(1, unit.toNanos(time));     }      @Override     public void unlock() {         sync.release(1);     }      @Override     public Condition newCondition() {         return sync.newCondition();     } } AQS实现
　　底层数据结构：同步队列
　　AQS中使用一个双向链表来保存等待同步状态的线程，链表的节点用其内部自定义的Node表示，Node类源码： static final class Node {     static final Node SHARED = new Node();     static final Node EXCLUSIVE = null;          volatile int waitStatus;     volatile Node prev;     volatile Node next;          volatile Thread thread;     Node nextWaiter; }
　　waitStatus有五个状态： cancelled = 1：同步队列中的线程等待超时或者中断时的状态，后续不会再改变。 signal = -1：节点获取同步状态，一般是队头节点，后续节点处于等待状态。 condition = -2：节点在等待队列中（注意不是同步队列），线程等待Condition，当Condition调用了signal()之后，该节点会从 等待队列 转移到 同步队列 。 propagate = -3： initial = 0：初始状态。
　　同步队列采用尾插法的方式，同时会使用CAS保证尾插的时候是线程安全的。其结构如下：
　　其中队头是获取同步状态成功的节点，当首节点的线程释放同步状态的时候，会唤醒后继的节点，后继节点会成为首节点。（这个过程不用CAS，没有竞争的情况。）
　　acquire方法流程 public final void acquire(int arg) {     if (!tryAcquire(arg) &&         acquireQueued(addWaiter(Node.EXCLUSIVE), arg))         selfInterrupt(); }
　　同步队列中的节点不断地在自旋判断其 前驱节点是不是头节点 ，如果是则尝试获取同步状态，否则会阻塞节点中的线程。
　　acquireShared方法流程 public final void acquireShared(int arg) {     if (tryAcquireShared(arg) < 0)         doAcquireShared(arg); }
　　ReetantLock
　　ReentrantLock，支持重入锁和公平与非公平锁。 ReentrantLock实现可重入
　　重入锁：支持线程反复地获取锁资源而不会自己阻塞自己，有两个问题要实现： 线程再次获取锁，判断是否是当前线程获取锁。 锁的最终释放，需要计数锁被重入几次，计数器最终释放为0时才表示锁的最终释放。
　　例如非公平锁每次再尝试获取锁的时候都会判断是不是同个线程，如果是的话增加计数器的值。释放锁时等到计数器的值为0时才将占有锁的线程设置为null。
　　公平锁与非公平锁
　　公平锁：获取锁的线程按照绝对的时间顺序，FIFO。
　　非公平锁：只要CAS设置同步状态成功，就获取锁，不会按照FIFO顺序。
　　ReentrantLock的构造方法中传入true时可以创建公平锁： public ReentrantLock(boolean fair) {     sync = fair ? new FairSync() : new NonfairSync(); }
　　公平锁在tryAcquire的时候会判断当前线程是否有前驱节点，有的话则会等待前驱节点释放之后在获取尝试获取锁。 公平锁的tryAcquire：
　　hasQueuePredecessors方法用来判断是否有前驱节点
　　非公平锁的tryAcquire：
　　问：如何实现公平锁？ 构造函数的参数传入true，在重写的tryAcquire方法中判断当前线程是否有前驱线程，有的话尝试获取同步状态失败，以此来达到公平的效果。
　　对比： 公平锁虽然会按照FIFO原则，但是会进行大量的线程切换，非公平锁虽然可能会造成其他线程饥饿，但是可以极大提高吞吐量。