JDK源码之ReentrantLock源码分析

ReentrantLock类似于synchronized是一种独占式锁(悲观锁)，是基于AQS实现的轻量级锁，相比于synchronized优点在于：

• 可自由选择锁的获取方式：公平锁和非公平锁
• 支持可重入锁，即一个线程可以多次获取锁
• 支持设置获取锁的持有时间

通过构造方法可以看到提供两种模式，默认为非公平锁

    //非公平锁
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    //公平锁
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

• 首先看看非公平锁

    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        final void lock() {
            //首先使用CAS进行设置，如果设置成功，则将当前线程设置为独占式线程，否则通过acquire获取
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

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

1. lock方法首先使用CAS进行设置，如果设置成功，则将当前线程设置为独占式线程，否则通过acquire（可以看看上一节中AQS的实现源码）获取，这里看一下nonfairTryAcquire方法

        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;
        }

首先获取同步状态，如果状态为0，则尝试用CAS设置状态，设置成功了则直接返回true,否则判断是不是当前线程再一次获取同步状态并将同步状态累加1

 

• 公平锁与非公平锁的唯一区别在于获取锁的时候判断当前线程是否有前驱节点（hasQueuedPredecessors方法），从而严格按照FIFO的方式出入队列 

    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

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

        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;
        }
    }

最后看看是如何进行同步状态的释放的,unLock方法内部分代码实现分析

        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;
        }

这里看到对于可重入锁，当有多少次lock就相对应的有多少次unlock操作，直到state同步状态为0，才释放了同步状态，并将独占线程设置为Null，整体的源码分析就讲到这里了，还是鼓励大家自己看看源码才才有收获