面经手册 · 第 17 篇《码农会锁，ReentrantLock 之 AQS 原理分析和实践使用》

public class SyncLock {
    private final Sync sync;
    public SyncLock() {        sync = new Sync();    }
    public void lock() {        sync.acquire(1);    }
    public void unlock() {        sync.release(1);    }
    private static class Sync extends AbstractQueuedSynchronizer {        @Override        protected boolean tryAcquire(int arg) {            return compareAndSetState(0, 1);        }
        @Override        protected boolean tryRelease(int arg) {            setState(0);            return true;        }
        // 该线程是否正在独占资源，只有用到 Condition 才需要去实现        @Override        protected boolean isHeldExclusively() {            return getState() == 1;        }    }
}

@Testpublic void test_SyncLock() throws InterruptedException {    final SyncLock lock = new SyncLock();    for (int i = 0; i < 10; i++) {        Thread.sleep(200);        new Thread(new TestLock(lock), String.valueOf(i)).start();    }    Thread.sleep(100000);}
static class TestLock implements Runnable {    private SyncLock lock;    public TestLock(SyncLock lock) throws InterruptedException {        this.lock = lock;    }    @Override    public void run() {        try {            lock.lock();            Thread.sleep(1000);            System.out.println(String.format("Thread %s Completed", Thread.currentThread().getName()));        } catch (Exception e) {            e.printStackTrace();        } finally {            lock.unlock();        }    }}

Thread 0 CompletedThread 1 CompletedThread 2 CompletedThread 3 CompletedThread 4 CompletedThread 5 CompletedThread 6 CompletedThread 7 CompletedThread 8 CompletedThread 9 Completed

final void lock() {    if (compareAndSetState(0, 1))        setExclusiveOwnerThread(Thread.currentThread());    else        acquire(1);}

protected final boolean compareAndSetState(int expect, int update) {    // See below for intrinsics setup to support this    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);}

stateOffset = unsafe.objectFieldOffset    (AbstractQueuedSynchronizer.class.getDeclaredField("state"));

<!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-cli --><dependency>    <groupId>org.openjdk.jol</groupId>    <artifactId>jol-cli</artifactId>    <version>0.14</version></dependency>

@Testpublic void test_stateOffset() throws Exception {    Unsafe unsafe = getUnsafeInstance();    long state = unsafe.objectFieldOffset            (AbstractQueuedSynchronizer.class.getDeclaredField("state"));    System.out.println(state);}
// 16

public final void acquire(int arg) {    if (!tryAcquire(arg) &&        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))        selfInterrupt();}

final boolean nonfairTryAcquire(int acquires) {    final Thread current = Thread.currentThread();    int c = getState();    if (c == 0) {        if (compareAndSetState(0, acquires)) {            setExclusiveOwnerThread(current);            return true;        }    }    else if (current == getExclusiveOwnerThread()) {        int nextc = c + acquires;        if (nextc < 0) // overflow            throw new Error("Maximum lock count exceeded");        setState(nextc);        return true;    }    return false;}

private Node addWaiter(Node mode) {    Node node = new Node(Thread.currentThread(), mode);    Node pred = tail;    // 如果队列不为空, 使用 CAS 方式将当前节点设为尾节点    if (pred != null) {        node.prev = pred;        if (compareAndSetTail(pred, node)) {            pred.next = node;            return node;        }    }    // 队列为空、CAS失败，将节点插入队列    enq(node);    return node;}

private Node enq(final Node node) {    for (;;) {        Node t = tail;        if (t == null) { // Must initialize            if (compareAndSetHead(new Node()))                tail = head;        } else {            node.prev = t;            if (compareAndSetTail(t, node)) {                t.next = node;                return t;            }        }    }}

final boolean acquireQueued(final Node node, int arg) {    boolean failed = true;    try {        boolean interrupted = false;        for (;;) {            final Node p = node.predecessor();            // 当前节点的前驱就是head节点时, 再次尝试获取锁            if (p == head && tryAcquire(arg)) {                setHead(node);                p.next = null; // help GC                failed = false;                return interrupted;            }            // 获取锁失败后, 判断是否把当前线程挂起            if (shouldParkAfterFailedAcquire(p, node) &&                parkAndCheckInterrupt())                interrupted = true;        }    } finally {        if (failed)            cancelAcquire(node);    }}

private void setHead(Node node) {    head = node;    node.thread = null;    node.prev = null;}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {    int ws = pred.waitStatus;    if (ws == Node.SIGNAL)    	// SIGNAL 设置了前一个节点完结唤醒，安心干别的去了，这里是睡。        return true;    if (ws > 0) {        do {            node.prev = pred = pred.prev;        } while (pred.waitStatus > 0);        pred.next = node;    } else {        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);    }    return false;}

if (shouldParkAfterFailedAcquire(p, node) &&    parkAndCheckInterrupt())    interrupted = true;
// 线程挂起等待被唤醒    private final boolean parkAndCheckInterrupt() {    LockSupport.park(this);    return Thread.interrupted();}