ReentrantLock源码分析

本节看一下ReentrantLock类的源码

1.首先看一下类的定义

public class ReentrantLock implements Lock, java.io.Serializable

ReentrantLock实现了Lock接口

2.类的变量信息

private final Sync sync;

提供了同步机制

3.构造函数

    /**
     * Creates an instance of {@code ReentrantLock}.
     * This is equivalent to using {@code ReentrantLock(false)}.
     */
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    /**
     * Creates an instance of {@code ReentrantLock} with the
     * given fairness policy.
     *
     * @param fair {@code true} if this lock should use a fair ordering policy
     */
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

默认是创建了一个非公平版本的同步器

4.获取锁lock()的实现

    public void lock() {
        sync.lock();
    }

我们分别看一下公平版本和非公平版本lock的实现

    /**
     * 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.
         */
        final void lock() {
            if (compareAndSetState(0, 1))//设置状态为1，如果成功，则设置独占线程为当前线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);//否则获取锁，调用的AQS的获取锁方法
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&//如果未获取到锁，则将当前线程加入到等待队列中，等待被唤醒
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

ReentrantLock的Sync内部类继承了AQS，看一下非公平版本获取锁的实现：

        /**
         * 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) {//锁的数量为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);//设置状态+1
                return true;
            }
            return false;
        }

公平版本的获取锁

    /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

5.释放锁的unlock

    public void unlock() {
        sync.release(1);//调用的AQS的release
    }

AQS的release

    public final boolean release(int arg) {//释放锁成功，则唤醒等待队列中的下一个线程
        if (tryRelease(arg)) {
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

Sync实现的tryRelease

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//如果当前线程占有的锁个数为0，则设置独占锁线程为null
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);//否则，减少独占锁线程的持有锁个数。
            return free;
        }