JavaSE-多线程（5.2）- ReentrantLock （源码解析，公平模式）

JavaSE-多线程（5.2）- ReentrantLock （源码解析，公平模式）

ReentrantLock 解释

ReentrantLock 是 java JUC 包（java.util.concurrent）下的可重入锁工具类，具体功能实现依赖AbstractQueuedSynchronizer（AQS，抽象队列同步器），AQS 内部维护了一个变量 private volatile int state; 默认为 0，当线程上锁以后值变成 1 （state 值改变通过 CAS 实现），没有获取到锁的线程会加入等待对列。

ReentrantLock 使用举例

通过一个例子来分析 ReentrantLock 的执行原理：

public class FairLockAndNonFairLockTest {

    static class Task implements Runnable {
        private final ReentrantLock lock;
        private volatile int count = 0;

        public Task(boolean fair) {
            this.lock = new ReentrantLock(fair);
        }

        @Override
        public void run() {
            for (int i = 0; i < 3; i++) {
                doTask();
            }
        }

        private void doTask() {
            lock.lock();
            try {
                System.out.println("任务开始。。。, 线程：" + Thread.currentThread().getName() + " , count=" + count);
                count++;
                sleep(500);
                System.out.println("任务结束。。。, 线程：" + Thread.currentThread().getName() + " , count=" + count);
                printQueuedThreads(lock);
            } finally {
                lock.unlock();
            }
        }
    }

    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

    public static void printQueuedThreads(ReentrantLock lock) {
        Class<ReentrantLock> reentrantLockClass = (Class<ReentrantLock>) lock.getClass();
        try {
            // getQueuedThreads 方法访问权限是 protected ，所以通过反射方式访问
            Method getQueuedThreads = reentrantLockClass.getDeclaredMethod("getQueuedThreads");
            getQueuedThreads.setAccessible(true);
            // 获取 aqs 中的线程队列
            List<Thread> list = (List<Thread>) getQueuedThreads.invoke(lock);
            // 看 getQueuedThreads 方法源码可知，它的顺序是从tail开始 加入list的，这里给它倒过来，从 head 开始
            Collections.reverse(list);
            System.out.println(list);
        } catch (NoSuchMethodException e) {
            throw new RuntimeException(e);
        } catch (InvocationTargetException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) {
        Task task = new Task(true);
        for (int i = 0; i < 5; i++) {
            new Thread(task, "t" + (i + 1)).start();

            // 稍微延迟启动，让线程按顺序创建和启动
            sleep(10);
        }
    }
}

以上代码中启动了5个线程，它们各自都会执行task任务，每个task任务会循环3次调用 doTask 方法，doTask方法有加锁操作，每执行一次 count 加1，并且在doTask方法中会打印当前等待队列中的线程。
查看运行结果（是否和你预期一致？）：

任务开始。。。, 线程：t1 , count=0
任务结束。。。, 线程：t1 , count=1
[Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t2 , count=1
任务结束。。。, 线程：t2 , count=2
[Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main], Thread[t1,5,main]]
任务开始。。。, 线程：t3 , count=2
任务结束。。。, 线程：t3 , count=3
[Thread[t4,5,main], Thread[t5,5,main], Thread[t1,5,main], Thread[t2,5,main]]
任务开始。。。, 线程：t4 , count=3
任务结束。。。, 线程：t4 , count=4
[Thread[t5,5,main], Thread[t1,5,main], Thread[t2,5,main], Thread[t3,5,main]]
任务开始。。。, 线程：t5 , count=4
任务结束。。。, 线程：t5 , count=5
[Thread[t1,5,main], Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main]]
任务开始。。。, 线程：t1 , count=5
任务结束。。。, 线程：t1 , count=6
[Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t2 , count=6
任务结束。。。, 线程：t2 , count=7
[Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main], Thread[t1,5,main]]
任务开始。。。, 线程：t3 , count=7
任务结束。。。, 线程：t3 , count=8
[Thread[t4,5,main], Thread[t5,5,main], Thread[t1,5,main], Thread[t2,5,main]]
任务开始。。。, 线程：t4 , count=8
任务结束。。。, 线程：t4 , count=9
[Thread[t5,5,main], Thread[t1,5,main], Thread[t2,5,main], Thread[t3,5,main]]
任务开始。。。, 线程：t5 , count=9
任务结束。。。, 线程：t5 , count=10
[Thread[t1,5,main], Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main]]
任务开始。。。, 线程：t1 , count=10
任务结束。。。, 线程：t1 , count=11
[Thread[t2,5,main], Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t2 , count=11
任务结束。。。, 线程：t2 , count=12
[Thread[t3,5,main], Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t3 , count=12
任务结束。。。, 线程：t3 , count=13
[Thread[t4,5,main], Thread[t5,5,main]]
任务开始。。。, 线程：t4 , count=13
任务结束。。。, 线程：t4 , count=14
[Thread[t5,5,main]]
任务开始。。。, 线程：t5 , count=14
任务结束。。。, 线程：t5 , count=15
[]

以上，由于线程启动后 sleep(10); 所以总是线程 t1 先执行，其他线程由于竞争不到锁会依次加入到等待队列中，当线程 t1 执行完 1 次后，t1释放锁，t1 会继续循环，但是由于是公平模式，所以 t1 会加入到等待队列，t2 成功获取锁继续执行，依次交替执行。

ReentrantLock 源码解析

ReentrantLock 源码如下：

package java.util.concurrent.locks;
import java.util.concurrent.TimeUnit;
import java.util.Collection;

/**
 * @since 1.5
 * @author Doug Lea
 */
public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    /** Synchronizer providing all implementation mechanics */
    private final Sync sync;

    /**
     * Base of synchronization control for this lock. Subclassed
     * into fair and nonfair versions below. Uses AQS state to
     * represent the number of holds on the lock.
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        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;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

        protected final boolean isHeldExclusively() {
            // While we must in general read state before owner,
            // we don't need to do so to check if current thread is owner
            return getExclusiveOwnerThread() == Thread.currentThread();
        }

        final ConditionObject newCondition() {
            return new ConditionObject();
        }

        // Methods relayed from outer class

        final Thread getOwner() {
            return getState() == 0 ? null : getExclusiveOwnerThread();
        }

        final int getHoldCount() {
            return isHeldExclusively() ? getState() : 0;
        }

        final boolean isLocked() {
            return getState() != 0;
        }

        /**
         * Reconstitutes the instance from a stream (that is, deserializes it).
         */
        private void readObject(java.io.ObjectInputStream s)
            throws java.io.IOException, ClassNotFoundException {
            s.defaultReadObject();
            setState(0); // reset to unlocked state
        }
    }

    /**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.