一个 int，一条排队的链

lock.lock();
try { … } finally { lock.unlock(); }      // 一定放 finally
if (lock.tryLock(1, SECONDS)) { … }       // 等 1 秒拿不到就算了
Condition notFull = lock.newCondition();
while (q.isFull()) notFull.await();       // 一定写 while
notFull.signal();
Semaphore sem = new Semaphore(10);        // 最多 10 个并发
sem.acquire(); try { … } finally { sem.release(); }
CountDownLatch done = new CountDownLatch(3);
done.countDown();  done.await(5, SECONDS);

class BooleanLatch {
  private static class Sync extends AbstractQueuedSynchronizer {
    protected int tryAcquireShared(int ignore) {
      return getState() != 0 ? 1 : -1;      // 开了就放行
    }
    protected boolean tryReleaseShared(int ignore) {
      setState(1); return true;            // 打开，叫醒等的人
    }
  }
  private final Sync sync = new Sync();
  public void signal() { sync.releaseShared(1); }
  public void await() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
  }
}

1197    public final void acquire(int arg) {1198        if (!tryAcquire(arg) &&❶1199            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))❷1200            selfInterrupt();1201    }⋮605    private Node addWaiter(Node mode) {606        Node node = new Node(Thread.currentThread(), mode);607        // Try the fast path of enq; backup to full enq on failure608        Node pred = tail;609        if (pred != null) {❸610            node.prev = pred;611            if (compareAndSetTail(pred, node)) {❹612                pred.next = node;613                return node;614            }615        }616        enq(node);❺617        return node;618    }⋮583    private Node enq(final Node node) {584        for (;;) {585            Node t = tail;586            if (t == null) { // Must initialize❻587                if (compareAndSetHead(new Node()))❼588                    tail = head;589            } else {590                node.prev = t;591                if (compareAndSetTail(t, node)) {592                    t.next = node;593                    return t;594                }595            }596        }597    }

857    final boolean acquireQueued(final Node node, int arg) {858        boolean failed = true;859        try {860            boolean interrupted = false;861            for (;;) {862                final Node p = node.predecessor();863                if (p == head && tryAcquire(arg)) {❽864                    setHead(node);❾865                    p.next = null; // help GC866                    failed = false;867                    return interrupted;868                }869                if (shouldParkAfterFailedAcquire(p, node) &&❿870                    parkAndCheckInterrupt())871                    interrupted = true;872            }873        } finally {874            if (failed)875                cancelAcquire(node);876        }877    }⋮795    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {796        int ws = pred.waitStatus;797        if (ws == Node.SIGNAL)undefined798            /*799             * This node has already set status asking a release800             * to signal it, so it can safely park.801             */802            return true;803        if (ws > 0) {undefined804            /*805             * Predecessor was cancelled. Skip over predecessors and806             * indicate retry.807             */808            do {809                node.prev = pred = pred.prev;810            } while (pred.waitStatus > 0);811            pred.next = node;812        } else {813            /*814             * waitStatus must be 0 or PROPAGATE.  Indicate that we815             * need a signal, but don't park yet.  Caller will need to816             * retry to make sure it cannot acquire before parking.817             */818            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);undefined819        }820        return false;821    }

1092    public final boolean release(int arg) {1093        if (tryRelease(arg)) {1094            signalNext(head);❶1095            return true;1096        }1097        return false;1098    }⋮641    private static void signalNext(Node h) {642        Node s;643        if (h != null && (s = h.next) != null && s.status != 0) {❷644            s.getAndUnsetStatus(WAITING);645            LockSupport.unpark(s.waiter);❸646        }647    }

638    private void unparkSuccessor(Node node) {639        /*640         * If status is negative (i.e., possibly needing signal) try641         * to clear in anticipation of signalling.  It is OK if this642         * fails or if status is changed by waiting thread.643         */644        int ws = node.waitStatus;645        if (ws < 0)❹646            compareAndSetWaitStatus(node, ws, 0);647648        /*649         * Thread to unpark is held in successor, which is normally650         * just the next node.  But if cancelled or apparently null,651         * traverse backwards from tail to find the actual652         * non-cancelled successor.653         */654        Node s = node.next;655        if (s == null || s.waitStatus > 0) {❺656            s = null;657            for (Node t = tail; t != null && t != node; t = t.prev)❻658                if (t.waitStatus <= 0)659                    s = t;660        }661        if (s != null)662            LockSupport.unpark(s.thread);663    }

205        final void lock() {206            if (compareAndSetState(0, 1))❶207                setExclusiveOwnerThread(Thread.currentThread());208            else209                acquire(1);210        }⋮231        protected final boolean tryAcquire(int acquires) {232            final Thread current = Thread.currentThread();233            int c = getState();234            if (c == 0) {235                if (!hasQueuedPredecessors() &&❷236                    compareAndSetState(0, acquires)) {237                    setExclusiveOwnerThread(current);238                    return true;239                }240            }

223        final boolean initialTryLock() {224            Thread current = Thread.currentThread();225            if (compareAndSetState(0, 1)) { // first attempt is unguarded❶226                setExclusiveOwnerThread(current);227                return true;⋮279        protected final boolean tryAcquire(int acquires) {280            if (getState() == 0 && !hasQueuedPredecessors() &&❷281                compareAndSetState(0, acquires)) {282                setExclusiveOwnerThread(Thread.currentThread());283                return true;