彻底理解 AQS 我是懂了，你呢？

Acquire:    while (!tryAcquire(arg)) {          enqueue thread if it is not already queued;          possibly block current thread;       }    Release:       if (tryRelease(arg))          unblock the first queued thread;

class Mutex implements Lock, java.io.Serializable {
    // Our internal helper class    private static class Sync extends AbstractQueuedSynchronizer {        // 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 (!isHeldExclusively())                throw new IllegalMonitorStateException();            setExclusiveOwnerThread(null);            setState(0);            return true;        }
        // Reports whether in locked state        public boolean isLocked() {            return getState() != 0;        }
        public boolean isHeldExclusively() {            // a data race, but safe due to out-of-thin-air guarantees            return getExclusiveOwnerThread() == Thread.currentThread();        }
        // Provides a Condition        public Condition newCondition() {            return new ConditionObject();        }
        // Deserializes properly        private void readObject(ObjectInputStream s)                throws IOException, ClassNotFoundException {            s.defaultReadObject();            setState(0); // reset to unlocked state        }    }
    // The sync object does all the hard work. We just forward to it.    private final Sync sync = new Sync();
    public void lock() {        sync.acquire(1);    }
    public boolean tryLock() {        return sync.tryAcquire(1);    }
    public void unlock() {        sync.release(1);    }
    public Condition newCondition() {        return sync.newCondition();    }
    public boolean isLocked() {        return sync.isLocked();    }
    public boolean isHeldByCurrentThread() {        return sync.isHeldExclusively();    }
    public boolean hasQueuedThreads() {        return sync.hasQueuedThreads();    }
    public void lockInterruptibly() throws InterruptedException {        sync.acquireInterruptibly(1);    }
    public boolean tryLock(long timeout, TimeUnit unit)            throws InterruptedException {        return sync.tryAcquireNanos(1, unit.toNanos(timeout));    }}

class BooleanLatch {
    private static class Sync extends AbstractQueuedSynchronizer {        boolean isSignalled() {            return getState() != 0;        }
        protected int tryAcquireShared(int ignore) {            return isSignalled() ? 1 : -1;        }
        protected boolean tryReleaseShared(int ignore) {            setState(1);            return true;        }    }
    private final Sync sync = new Sync();
    public boolean isSignalled() {        return sync.isSignalled();    }
    public void signal() {        sync.releaseShared(1);    }
    public void await() throws InterruptedException {        sync.acquireSharedInterruptibly(1);    }}

static final class Node {
    /** 模式定义 */
    static final Node SHARED = new Node();    static final Node EXCLUSIVE = null;
    /** 线程状态 */
    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;
    /** 对于独占模式而言，指向下一个处于 CONDITION 等待状态的结点；对于共享模式而言，则为 SHARED 结点 */    Node nextWaiter;
    // ... 省略方法定义}

    /**     * Head of the wait queue, lazily initialized.  Except for     * initialization, it is modified only via method setHead.  Note:     * If head exists, its waitStatus is guaranteed not to be     * CANCELLED.     */    private transient volatile Node head;
    /**     * Tail of the wait queue, lazily initialized.  Modified only via     * method enq to add new wait node.     */    private transient volatile Node 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(mode);
    for (;;) {        Node oldTail = tail;        if (oldTail != null) {            node.setPrevRelaxed(oldTail);            if (compareAndSetTail(oldTail, node)) {                oldTail.next = node;                return node;            }        } else {            initializeSyncQueue();        }    }}

  protected final boolean tryRelease(int releases) {        int c = getState() - releases;         if (Thread.currentThread() != getExclusiveOwnerThread())            throw new IllegalMonitorStateException();        boolean free = false;        if (c == 0) { // 如果 state=0 了，就是可以释放锁了            free = true;             setExclusiveOwnerThread(null); // 将拿锁线程置为 null        }        setState(c); // 重置同步器的 state        return free; // 返回是否成功释放  }
  private void unparkSuccessor(Node node) {    // node 节点是当前释放锁的节点，也是同步队列的头节点    int ws = node.waitStatus;    // 如果节点已经被取消了，把节点的状态置为初始化    if (ws < 0)        compareAndSetWaitStatus(node, ws, 0);
    // 拿出队二 s    Node s = node.next;    // s 为空，表示 node 的后一个节点为空    // s.waitStatus 大于 0，代表 s 节点已经被取消了    // 遇到以上这两种情况，就从队尾开始，向前遍历，找到第一个 waitStatus 字段不是被取消的    if (s == null || s.waitStatus > 0) {        s = null;               // 结束条件是前置节点就是 head 了        for (Node t = tail; t != null && t != node; t = t.prev)            // t.waitStatus <= 0 说明 t 当前没有被取消，肯定还在等待被唤醒            if (t.waitStatus <= 0)                s = t;    }    // 唤醒以上代码找到的线程    if (s != null)        LockSupport.unpark(s.thread);}

 /** * 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 interrupted = false;    try {        for (;;) {            //获取前驱节点            final Node p = node.predecessor();            //如果前驱节点是首节点，获取资源（子类实现）            if (p == head && tryAcquire(arg)) {                //获取资源成功，设置当前节点为头节点，清空当前节点的信息，把当前节点变成哨兵节点                setHead(node);                //原来首节点下个节点指向为 null                p.next = null; // help GC                //返回线程中断状态                return interrupted;            }            if (shouldParkAfterFailedAcquire(p, node))                interrupted |= parkAndCheckInterrupt();        }    } catch (Throwable t) {        cancelAcquire(node);        if (interrupted)            selfInterrupt();        throw t;    }}

 private Lock lock = new ReentrantLock(); private Condition FirstCond = lock.newCondition(); private Condition SecondCond = lock.newCondition();

public class NonReentrantLock implements Lock {
    /**     *      * @Description 自定义同步器     */    private static class Sync extends AbstractQueuedSynchronizer {
        /**         * 锁是否被线程持有         */        @Override        protected boolean isHeldExclusively() {            //0：未持有 1：已持有            return super.getState() == 1;        }
        /**         * 获取锁         */        @Override        protected boolean tryAcquire(int arg) {            if (arg != 1) {                //获取锁操作，是需要把 state 更新为 1，所以 arg 必须是 1                throw new RuntimeException("arg not is 1");            }            if (compareAndSetState(0, arg)) {//cas 更新 state 为 1 成功，代表获取锁成功                //设置持有锁线程                setExclusiveOwnerThread(Thread.currentThread());                return true;            }            return false;        }
        /**         * 释放锁         */        @Override        protected boolean tryRelease(int arg) {            if (arg != 0) {                //释放锁操作，是需要把 state 更新为 0，所以 arg 必须是 0                throw new RuntimeException("arg not is 0");            }            //清空持有锁线程            setExclusiveOwnerThread(null);            //设置 state 状态为 0，此处不用 cas，因为只有获取锁成功的线程才会执行该函数，不需要考虑线程安全问题            setState(arg);            return true;        }
        /**         * 提供创建条件变量入口         */        public ConditionObject createConditionObject() {            return new ConditionObject();        }
    }
    private final Sync sync = new Sync();
    /**     * 获取锁     */    @Override    public void lock() {        //Aqs 独占式-获取资源模板函数        sync.acquire(1);    }            /**     * 获取锁-响应中断     */    @Override    public void lockInterruptibly() throws InterruptedException {        //Aqs 独占式-获取资源模板函数（响应线程中断）        sync.acquireInterruptibly(1);    }
    /**     * 获取锁是否成功-不阻塞     */    @Override    public boolean tryLock() {        //子类实现        return sync.tryAcquire(1);    }        /**     * 获取锁-超时机制     */    @Override    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {        //Aqs 独占式-获取资源模板函数（超时机制）        return sync.tryAcquireNanos(1,unit.toNanos(time));    }        /**     * 释放锁     */    @Override    public void unlock() {        //Aqs 独占式-释放资源模板函数        sync.release(0);    }        /**     * 创建条件变量     */    @Override    public Condition newCondition() {        return sync.createConditionObject();    }}

    private static int j = 0;
    public static void main(String[] agrs) throws InterruptedException {        NonReentrantLock  nonReentrantLock = new NonReentrantLock();
        Runnable runnable = () -> {            //获取锁            nonReentrantLock.lock();            for (int i = 0; i < 100000; i++) {                j++;            }            //释放锁            nonReentrantLock.unlock();        };
        Thread thread = new Thread(runnable);        Thread threadTwo = new Thread(runnable);
        thread.start();        threadTwo.start();
        thread.join();        threadTwo.join();
        System.out.println(j);    }    
无论执行多少次输出内容都是：200000