1Acquire:
2    while (!tryAcquire(arg)) {
3          enqueue thread if it is not already queued;
4          possibly block current thread;
5       }
6 
7   Release:
8       if (tryRelease(arg))
9          unblock the first queued thread;

 1class Mutex implements Lock, java.io.Serializable {
 2
 3    // Our internal helper class
 4    private static class Sync extends AbstractQueuedSynchronizer {
 5        // Acquires the lock if state is zero
 6        public boolean tryAcquire(int acquires) {
 7            assert acquires == 1; // Otherwise unused
 8            if (compareAndSetState(0, 1)) {
 9                setExclusiveOwnerThread(Thread.currentThread());
10                return true;
11            }
12            return false;
13        }
14
15        // Releases the lock by setting state to zero
16        protected boolean tryRelease(int releases) {
17            assert releases == 1; // Otherwise unused
18            if (!isHeldExclusively())
19                throw new IllegalMonitorStateException();
20            setExclusiveOwnerThread(null);
21            setState(0);
22            return true;
23        }
24
25        // Reports whether in locked state
26        public boolean isLocked() {
27            return getState() != 0;
28        }
29
30        public boolean isHeldExclusively() {
31            // a data race, but safe due to out-of-thin-air guarantees
32            return getExclusiveOwnerThread() == Thread.currentThread();
33        }
34
35        // Provides a Condition
36        public Condition newCondition() {
37            return new ConditionObject();
38        }
39
40        // Deserializes properly
41        private void readObject(ObjectInputStream s)
42                throws IOException, ClassNotFoundException {
43            s.defaultReadObject();
44            setState(0); // reset to unlocked state
45        }
46    }
47
48    // The sync object does all the hard work. We just forward to it.
49    private final Sync sync = new Sync();
50
51    public void lock() {
52        sync.acquire(1);
53    }
54
55    public boolean tryLock() {
56        return sync.tryAcquire(1);
57    }
58
59    public void unlock() {
60        sync.release(1);
61    }
62
63    public Condition newCondition() {
64        return sync.newCondition();
65    }
66
67    public boolean isLocked() {
68        return sync.isLocked();
69    }
70
71    public boolean isHeldByCurrentThread() {
72        return sync.isHeldExclusively();
73    }
74
75    public boolean hasQueuedThreads() {
76        return sync.hasQueuedThreads();
77    }
78
79    public void lockInterruptibly() throws InterruptedException {
80        sync.acquireInterruptibly(1);
81    }
82
83    public boolean tryLock(long timeout, TimeUnit unit)
84            throws InterruptedException {
85        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
86    }
87}

 1
 2class BooleanLatch {
 3
 4    private static class Sync extends AbstractQueuedSynchronizer {
 5        boolean isSignalled() {
 6            return getState() != 0;
 7        }
 8
 9        protected int tryAcquireShared(int ignore) {
10            return isSignalled() ? 1 : -1;
11        }
12
13        protected boolean tryReleaseShared(int ignore) {
14            setState(1);
15            return true;
16        }
17    }
18
19    private final Sync sync = new Sync();
20
21    public boolean isSignalled() {
22        return sync.isSignalled();
23    }
24
25    public void signal() {
26        sync.releaseShared(1);
27    }
28
29    public void await() throws InterruptedException {
30        sync.acquireSharedInterruptibly(1);
31    }
32}

 1static final class Node {
 2
 3    /** 模式定义 */
 4
 5    static final Node SHARED = new Node();
 6    static final Node EXCLUSIVE = null;
 7
 8    /** 线程状态 */
 9
10    static final int CANCELLED = 1;
11    static final int SIGNAL = -1;
12    static final int CONDITION = -2;
13    static final int PROPAGATE = -3;
14
15    /** 线程等待状态 */
16    volatile int waitStatus;
17
18    /** 前驱结点 */
19    volatile Node prev;
20    /** 后置结点 */
21    volatile Node next;
22
23    /** 持有的线程对象 */
24    volatile Thread thread;
25
26    /** 对于独占模式而言，指向下一个处于 CONDITION 等待状态的结点；对于共享模式而言，则为 SHARED 结点 */
27    Node nextWaiter;
28
29    // ... 省略方法定义
30}

 1
 2    /**
 3     * Head of the wait queue, lazily initialized.  Except for
 4     * initialization, it is modified only via method setHead.  Note:
 5     * If head exists, its waitStatus is guaranteed not to be
 6     * CANCELLED.
 7     */
 8    private transient volatile Node head;
 9
10    /**
11     * Tail of the wait queue, lazily initialized.  Modified only via
12     * method enq to add new wait node.
13     */
14    private transient volatile Node tail;

 1/**
 2 * Creates and enqueues node for current thread and given mode.
 3 *
 4 * @param mode Node.EXCLUSIVE for exclusive, Node.SHARED for shared
 5 * @return the new node
 6 */
 7private Node addWaiter(Node mode) {
 8    Node node = new Node(mode);
 9
10    for (;;) {
11        Node oldTail = tail;
12        if (oldTail != null) {
13            node.setPrevRelaxed(oldTail);
14            if (compareAndSetTail(oldTail, node)) {
15                oldTail.next = node;
16                return node;
17            }
18        } else {
19            initializeSyncQueue();
20        }
21    }
22}

 1
 2  protected final boolean tryRelease(int releases) {
 3        int c = getState() - releases; 
 4        if (Thread.currentThread() != getExclusiveOwnerThread())
 5            throw new IllegalMonitorStateException();
 6        boolean free = false;
 7        if (c == 0) { // 如果 state=0 了，就是可以释放锁了
 8            free = true; 
 9            setExclusiveOwnerThread(null); // 将拿锁线程置为 null
10        }
11        setState(c); // 重置同步器的 state
12        return free; // 返回是否成功释放
13  }
14
15  private void unparkSuccessor(Node node) {
16    // node 节点是当前释放锁的节点，也是同步队列的头节点
17    int ws = node.waitStatus;
18    // 如果节点已经被取消了，把节点的状态置为初始化
19    if (ws < 0)
20        compareAndSetWaitStatus(node, ws, 0);
21
22    // 拿出队二 s
23    Node s = node.next;
24    // s 为空，表示 node 的后一个节点为空
25    // s.waitStatus 大于 0，代表 s 节点已经被取消了
26    // 遇到以上这两种情况，就从队尾开始，向前遍历，找到第一个 waitStatus 字段不是被取消的
27    if (s == null || s.waitStatus > 0) {
28        s = null;
29     
30        // 结束条件是前置节点就是 head 了
31        for (Node t = tail; t != null && t != node; t = t.prev)
32            // t.waitStatus <= 0 说明 t 当前没有被取消，肯定还在等待被唤醒
33            if (t.waitStatus <= 0)
34                s = t;
35    }
36    // 唤醒以上代码找到的线程
37    if (s != null)
38        LockSupport.unpark(s.thread);
39}

 1 /**
 2 * Acquires in exclusive uninterruptible mode for thread already in
 3 * queue. Used by condition wait methods as well as acquire.
 4 *
 5 * @param node the node
 6 * @param arg the acquire argument
 7 * @return {@code true} if interrupted while waiting
 8 */
 9final boolean acquireQueued(final Node node, int arg) {
10    boolean interrupted = false;
11    try {
12        for (;;) {
13            //获取前驱节点
14            final Node p = node.predecessor();
15            //如果前驱节点是首节点，获取资源（子类实现）
16            if (p == head && tryAcquire(arg)) {
17                //获取资源成功，设置当前节点为头节点，清空当前节点的信息，把当前节点变成哨兵节点
18                setHead(node);
19                //原来首节点下个节点指向为 null
20                p.next = null; // help GC
21                //返回线程中断状态
22                return interrupted;
23            }
24            if (shouldParkAfterFailedAcquire(p, node))
25                interrupted |= parkAndCheckInterrupt();
26        }
27    } catch (Throwable t) {
28        cancelAcquire(node);
29        if (interrupted)
30            selfInterrupt();
31        throw t;
32    }
33}

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

  1
  2public class NonReentrantLock implements Lock {
  3
  4    /**
  5     * 
  6     * @Description 自定义同步器
  7     */
  8    private static class Sync extends AbstractQueuedSynchronizer {
  9
 10        /**
 11         * 锁是否被线程持有
 12         */
 13        @Override
 14        protected boolean isHeldExclusively() {
 15            //0：未持有 1：已持有
 16            return super.getState() == 1;
 17        }
 18
 19        /**
 20         * 获取锁
 21         */
 22        @Override
 23        protected boolean tryAcquire(int arg) {
 24            if (arg != 1) {
 25                //获取锁操作，是需要把 state 更新为 1，所以 arg 必须是 1
 26                throw new RuntimeException("arg not is 1");
 27            }
 28            if (compareAndSetState(0, arg)) {//cas 更新 state 为 1 成功，代表获取锁成功
 29                //设置持有锁线程
 30                setExclusiveOwnerThread(Thread.currentThread());
 31                return true;
 32            }
 33            return false;
 34        }
 35
 36        /**
 37         * 释放锁
 38         */
 39        @Override
 40        protected boolean tryRelease(int arg) {
 41            if (arg != 0) {
 42                //释放锁操作，是需要把 state 更新为 0，所以 arg 必须是 0
 43                throw new RuntimeException("arg not is 0");
 44            }
 45            //清空持有锁线程
 46            setExclusiveOwnerThread(null);
 47            //设置 state 状态为 0，此处不用 cas，因为只有获取锁成功的线程才会执行该函数，不需要考虑线程安全问题
 48            setState(arg);
 49            return true;
 50        }
 51
 52        /**
 53         * 提供创建条件变量入口
 54         */
 55        public ConditionObject createConditionObject() {
 56            return new ConditionObject();
 57        }
 58
 59    }
 60
 61    private final Sync sync = new Sync();
 62
 63    /**
 64     * 获取锁
 65     */
 66    @Override
 67    public void lock() {
 68        //Aqs 独占式-获取资源模板函数
 69        sync.acquire(1);
 70    }
 71        
 72    /**
 73     * 获取锁-响应中断
 74     */
 75    @Override
 76    public void lockInterruptibly() throws InterruptedException {
 77        //Aqs 独占式-获取资源模板函数（响应线程中断）
 78        sync.acquireInterruptibly(1);
 79    }
 80
 81    /**
 82     * 获取锁是否成功-不阻塞
 83     */
 84    @Override
 85    public boolean tryLock() {
 86        //子类实现
 87        return sync.tryAcquire(1);
 88    }
 89    
 90    /**
 91     * 获取锁-超时机制
 92     */
 93    @Override
 94    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
 95        //Aqs 独占式-获取资源模板函数（超时机制）
 96        return sync.tryAcquireNanos(1,unit.toNanos(time));
 97    }
 98    
 99    /**
100     * 释放锁
101     */
102    @Override
103    public void unlock() {
104        //Aqs 独占式-释放资源模板函数
105        sync.release(0);
106    }
107    
108    /**
109     * 创建条件变量
110     */
111    @Override
112    public Condition newCondition() {
113        return sync.createConditionObject();
114    }
115}

 1    private static int j = 0;
 2
 3    public static void main(String[] agrs) throws InterruptedException {
 4        NonReentrantLock  nonReentrantLock = new NonReentrantLock();
 5
 6        Runnable runnable = () -> {
 7            //获取锁
 8            nonReentrantLock.lock();
 9            for (int i = 0; i < 100000; i++) {
10                j++;
11            }
12            //释放锁
13            nonReentrantLock.unlock();
14        };
15
16        Thread thread = new Thread(runnable);
17        Thread threadTwo = new Thread(runnable);
18
19        thread.start();
20        threadTwo.start();
21
22        thread.join();
23        threadTwo.join();
24
25        System.out.println(j);
26    }
27    
28
29无论执行多少次输出内容都是：
30200000