Java源码解析之详解ReentrantLock

private final ReentrantLock lock = new ReentrantLock();
 
public void methodA() {
    try {
        lock.lock();//<1>
        methodB();//<2>
        //methodA body...
    } finally {
        lock.unlock();//<3>
    }
 
}
 
public void methodB() {
    try {
        lock.lock();//<4>
        //methodB body...
    } finally {
        lock.unlock();//<5>
    }
}

private final ReentrantLock lock = new ReentrantLock();
 
public void methodA() {
    try {
        lock.lock();
        methodB();
        methodC();
        //methodA body...
    } finally {
        lock.unlock();
    }
}
 
public void methodB() {
    if (lock.getHoldCount() != 0) {
        //methodB body...
    }
}
 
public void methodC() {
    if (lock.isHeldByCurrentThread()) {
        //methodC body...
    }
}

public class ReentrantLock implements Lock, java.io.Serializable {
    //...
    //默认创建非公平锁
    public ReentrantLock() {
        sync = new NonfairSync();
    }
     
    //根据参数指定创建公平锁或非公平锁，true为公平锁。
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }
    //...
}

public void methodA() {
    try {
        lock.lock();
        //methodA body...
    } finally {
        lock.unlock();
    }
}
 
public void doThread3() {
    for (int i = 0; i < 10; i++) {
        methodA();
    }
}

public void methodD() {
    boolean hasLock = false;
    try {
        hasLock = lock.tryLock();//<1>非计时
        if (!hasLock) {//没有抢到锁则退出
            return;
        }
        //methodD body...
    } finally {
        if (hasLock) {
            lock.unlock();
        }
    }
}
 
public void methodE() {
    boolean hasLock = false;
    try {
        hasLock = lock.tryLock(5, TimeUnit.SECONDS);//<2>计时
        if (!hasLock) {//没有抢到锁则退出
            return;
        }
        //methodE body...
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (hasLock) {
            lock.unlock();
        }
    }
}

public void methodD() {
    boolean hasLock = false;
    try {
        hasLock = lock.tryLock();//<1>非计时
        if (!hasLock) {//没有抢到锁则退出
            return;
        }
        //methodD body...
    } finally {
        if (hasLock) {
            lock.unlock();
        }
    }
}
 
public void methodE() {
    boolean hasLock = false;
    try {
        hasLock = lock.tryLock(5, TimeUnit.SECONDS);//<2>计时
        if (!hasLock) {//没有抢到锁则退出
            return;
        }
        //methodE body...
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        if (hasLock) {
            lock.unlock();
        }
    }
}

//java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))//<1>
            selfInterrupt();
    }
 
//AbstractQueuedSynchronizer将tryAcquire(int arg)的实现交由子类
//java.util.concurrent.locks.AbstractQueuedSynchronizer#tryAcquire
    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

//当调用AQS的acquire(int arg)时，会先调用由子类实现的tryAcquire(int acquires)方法
//java.util.concurrent.locks.ReentrantLock.NonfairSync#tryAcquire
    protected final boolean tryAcquire(int acquires) {
            //这里会调用父类Sync的nonfairTryAcquire(int acquires)方法
            return nonfairTryAcquire(acquires);
        }
//java.util.concurrent.locks.ReentrantLock.Sync#nonfairTryAcquire
        final boolean nonfairTryAcquire(int acquires) {
            //获取当前线程对象
            final Thread current = Thread.currentThread();
            //这里会获取父类AQS的state字段，在可重入互斥锁里，state表示占有锁的线程的引用计数
            int c = getState();
            //如果state为0，表示目前锁是无主状态
            if (c == 0) {
                //如果锁处于无主状态，则用CAS修改state，如果修改成功，表示占有锁成功
                if (compareAndSetState(0, acquires)) {//<1>
                    //占有锁成功后，这里会设置锁的独占线程
                    setExclusiveOwnerThread(current);//<2>
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {//<3>如果state不为0，代表现在有线程占据锁，如果请求锁的线程和独占线程是同一个线程，则增加当前线程对锁的引用计数
                //锁的最大可重入次数为(2^31-1)，超过这个最大范围，int就会变为负数，判断nextc为负数时报错。
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //重新设置state的值
                setState(nextc);//<4>
                return true;
            }
            return false;
        }
 
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    //...
    //在可重入互斥锁中，state代表独占线程当前的重入次数
    private volatile int state;
     
    protected final int getState() {
        return state;
    }
     
    protected final void setState(int newState) {
        state = newState;
    }
    //...
}
 
public abstract class AbstractOwnableSynchronizer
    implements java.io.Serializable {
    //...
    //独占线程，当有线程占据可重入互斥锁时，会用此字段存储占有锁的线程
    private transient Thread exclusiveOwnerThread;
     
    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }
     
    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

//java.util.concurrent.locks.AbstractQueuedSynchronizer.Node
    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;
        //...
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
        Node nextWaiter;
        //...
        //返回当前节点的前驱节点
        final Node predecessor() {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }
        Node() {}
        //...
        //创建Node节点
        Node(Node nextWaiter) {//<1>
            this.nextWaiter = nextWaiter;
            THREAD.set(this, Thread.currentThread());
        }
    }

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    //...
    private transient volatile Node head;//等待队列的头节点
    private transient volatile Node tail;//等待队列的尾节点
    //...
    private Node addWaiter(Node mode) {
        //为竞争锁的线程创建一个Node对象，并用Node.thread字段存储调用线程Thread对象
        Node node = new Node(mode);//<1>
 
        for (;;) {//<2>
            Node oldTail = tail;
            if (oldTail != null) {//<3>
                node.setPrevRelaxed(oldTail);
                if (compareAndSetTail(oldTail, node)) {
                    oldTail.next = node;
                    return node;
                }
            } else {//<4>
                initializeSyncQueue();
            }
        }
    }
 
    private final void initializeSyncQueue() {
        Node h;
        if (HEAD.compareAndSet(this, null, (h = new Node())))
            tail = h;
    }
     
    private final boolean compareAndSetTail(Node expect, Node update) {
        return TAIL.compareAndSet(this, expect, update);
    }
    //...
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    //...
    private transient volatile Node head;
    //...
    final boolean acquireQueued(final Node node, int arg) {
        boolean interrupted = false;
        try {
            for (;;) {
                final Node p = node.predecessor();//<1>
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node))//<2>
                    interrupted |= parkAndCheckInterrupt();
            }
        } catch (Throwable t) {
            cancelAcquire(node);//<6>
            if (interrupted)
                selfInterrupt();
            throw t;
        }
    }
    //...
    //设置当前节点为头节点，此时可以清空头节点指向的线程引用
    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)//<3>
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        if (ws > 0) {//<5>
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {//<4>
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            pred.compareAndSetWaitStatus(ws, Node.SIGNAL);
        }
        return false;
    }
    //...
    private final boolean parkAndCheckInterrupt() {
        //阻塞调用线程，可调用LockSupport.unpark(Thread thread)唤醒或由线程中断唤醒。
        LockSupport.park(this);
        //返回线程是否由中断唤醒，返回true为被中断唤醒，但此方法会清除线程的中断标记
        return Thread.interrupted();
    }
    //...
}

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    //...
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            //根据acquireQueued()的返回，决定是否设置线程的中断标记
            selfInterrupt();
    }
    //...
    static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }
    //...
}