java并发编程笔记之详解ReentrantLock

---

转载自程序员阿星，本文只作为个人笔记，方便知识整理。

ReentrantLock是可重入的互斥锁，虽然具有与synchronized相同功能，但是会比synchronized更加灵活。ReentrantLock底层基于AbstractQueuedSynchronizer实现

ReentrantLock结构组成

首先ReentrantLock实现了Lock接口，Lock接口是Java中对锁操作行为的统一规范。

public interface Lock {
    /**
     * 获取锁
     */
    void lock();

    /**
     * 获取锁-响应中断 
     */
    void lockInterruptibly() throws InterruptedException;

    /**
     * 返回获取锁是否成功状态
     */
    boolean tryLock();

    /**
     * 返回获取锁是否成功状态-响应中断 
     */
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    /**
     * 释放锁
     */
    void unlock();

    /**
     * 创建条件变量
     */
    Condition newCondition();
}

ReentrantLock内部定义了专门的组件Sync， Sync继承AbstractQueuedSynchronizer提供释放资源的实现，NonfairSync和FairSync是基于Sync扩展的子类，即ReentrantLock的非公平模式与公平模式，它们作为Lock接口功能的基本实现。

sync

源码：

abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * 获取锁-子类实现
         */
        abstract void lock();

        /**
         * 非公平-获取资源
         */
        final boolean nonfairTryAcquire(int acquires) {
            //获取当前线程
            final Thread current = Thread.currentThread();
            //获取当前状态
            int c = getState();
            if (c == 0) { // state==0 代表资源可获取
                //cas设置state为acquires，acquires传入的是1
                if (compareAndSetState(0, acquires)) {
                    //cas成功，设置当前持有锁的线程
                    setExclusiveOwnerThread(current);
                    //返回成功
                    return true;
                }
            }
            //如果state!=0,但是当前线程是持有锁线程，直接重入
            else if (current == getExclusiveOwnerThread()) { 
                //state状态+1
                int nextc = c + acquires;
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                //设置state状态，此处不需要cas，因为持有锁的线程只有一个    
                setState(nextc);
                //返回成功
                return true;
            }
            //返回失败
            return false;
        }
        
        /**
         * 释放资源
         */
        protected final boolean tryRelease(int releases) {
            //state状态-releases，releases传入的是1
            int c = getState() - releases;
            //如果当前线程不是持有锁线程，抛出异常
            if (Thread.currentThread() != getExclusiveOwnerThread()) 
                throw new IllegalMonitorStateException();
            //设置返回状态，默认为失败
            boolean free = false;
            if (c == 0) {//state-1后，如果c==0代表释放资源成功
                //返回状态设置为true
                free = true;
                //清空持有锁线程
                setExclusiveOwnerThread(null);
            }
            // 如果state-1后，state还是>0，代表当前线程有锁重入操作，
            // 需要做相应的释放次数，设置state值
            setState(c);
            return free;
        }
}        

NonfarirSync

在ReentrantLock中支持两种获取锁的策略，分别是非公平策略与公平策略，NonfairSync就是非公平策略。
回顾一下AQS（AbstractQueuedSynchronizer）流程，AQS为加锁和解锁过程提供了统一的模板函数，加锁与解锁的模板流程是，获取锁失败的线程，会进入CLH队列阻塞，其他线程解锁会唤醒CLH队列线程，如下图所示（简化流程）

上图中，线程释放锁时，会唤醒CLH队列阻塞的线程，重新竞争锁，要注意，此时可能还有非CLH队列的线程参与竞争，所以非公平就体现在这里，非CLH队列线程与CLH队列线程竞争，各凭本事，不会因为你是CLH队列的线程，排了很久的队，就把锁让给你。

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

        /**
         * 获取锁
         */
        final void lock() {
            if (compareAndSetState(0, 1))//cas设置state为1成功，代表获取资源成功    
                //资源获取成功，设置当前线程为持有锁线程
                setExclusiveOwnerThread(Thread.currentThread());
            else
                //cas设置state为1失败，代表获取资源失败，执行AQS获取锁模板流程，否获取资源成功
                acquire(1);
        }
        
        /**
         * 获取资源-使用的是Sync提供的nonfairTryAcquire函数
         */
        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
    
    /**
     * AQS获取锁模板函数，这是AQS类中的函数
     */
    public final void acquire(int arg) {
        /**
         * 我们只需要关注tryAcquire函数，后面的函数是AQS获取资源失败，
         * 线程节点进入CLH队列的细节流程，本文不关注
         */
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

nonfairTryAcquire逻辑流程图：

FairSync

所谓公平策略就是，严格按照CLH队列顺序获取锁，线程释放锁时，会唤醒CLH队列阻塞的线程，重新竞争锁，要注意，此时可能还有非CLH队列的线程参与竞争，为了保证公平，一定会让CLH队列线程竞争成功，如果非CLH队列线程一直占用时间片，那就一直失败（构建成节点插入到CLH队尾，由A S Q模板流程执行），直到时间片轮到CLH队列线程为止，所以公平策略的性能会更差。

static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;
        
        /**
         * 获取锁
         */
        final void lock() {
        //执行AQS获取锁模板流程，否获取资源成功
            acquire(1);
        }

        /**
         * 获取资源
         */
        protected final boolean tryAcquire(int acquires) {
            //获取当前线程
            final Thread current = Thread.currentThread();
            //获取state状态
            int c = getState();
            if (c == 0) { // state==0 代表资源可获取
                //1.hasQueuedPredecessors判断当前线程是不是CLH队列被唤醒的线程，如果是执行下一个步骤
               //2.cas设置state为acquires，acquires传入的是1
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    //cas成功，设置当前持有锁的线程
                    setExclusiveOwnerThread(current);
                    //返回成功
                    return true;
                }
            }
            //如果state!=0,但是当前线程是持有锁线程，直接重入
            else if (current == getExclusiveOwnerThread()) {
                //state状态+1
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                //设置state状态，此处不需要cas，因为持有锁的线程只有一个 
                setState(nextc);
                //返回成功
                return true;
            }
            return false;
        }
    }
    public final boolean hasQueuedPredecessors() {
        Node t = tail; 
        Node h = head;
        Node s;
        // 返回true有三种情况：
        // (1)h==t，h.next==null，h.next != Thread.currentThread()
        // 只有当下列三个条件都满足时才返回false
        // (1)h!=t，h.next!=null，h.next == Thread.currentThread()
        // 总结：返回false表明当前线程是CLH的第二个节点，即应该被唤醒的线程
        return h != t &&
            ((s = h.next) == null || s.thread != Thread.currentThread());
    }

    /**
     * AQS获取锁模板函数，这是AQS类中的函数
     */
    public final void acquire(int arg) {
        /**
         * 我们只需要关注tryAcquire函数，后面的函数是AQS获取资源失败，线程节点进入CLH队列的细节流程，本文不关注
         */
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

其实我们不难发现FairSync流程与NonfairSync基本一致，唯一的区别就是在CAS执行前，多了一步hasQueuedPredecessors函数，这一步就是判断当前线程是不是CLH队列被唤醒的线程，如果是就执行CAS，否则获取资源失败。

Lock的实现

    //同步器
    private final Sync sync;
    
    //默认使用非公平策略
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    //true-公平策略 false非公平策略
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

ReentrantLock默认是使用非公平策略，如果想指定模式，可以通过入参fair来选择，这里就不做过多概述，接下来看看ReentrantLock对Lock的实现

public class ReentrantLock implements Lock, java.io.Serializable {
    private static final long serialVersionUID = 7373984872572414699L;
    //同步器
    private final Sync sync;

    //默认使用非公平策略
    public ReentrantLock() {
        sync = new NonfairSync();
    }

    //true-公平策略 false非公平策略
    public ReentrantLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
    }

    /**
     * 获取锁-阻塞
     */
    public void lock() {
        //基于sync实现
        sync.lock();
    }

    /**
     * 获取锁-阻塞，支持响应线程中断
     */
    public void lockInterruptibly() throws InterruptedException {
        //基于sync实现
        sync.acquireInterruptibly(1);
    }

    /**
     * 获取资源，返回是否成功状态-非阻塞
     */
    public boolean tryLock() {
        //基于sync实现
        return sync.nonfairTryAcquire(1);
    }

    /**
     * 获取锁-阻塞，支持超时 
     */
    public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
        //基于sync实现    
        return sync.tryAcquireNanos(1, unit.toNanos(timeout));
    }

    /**
     * 释放锁
     */
    public void unlock() {
        //基于sync实现
        sync.release(1);
    }

    /**
     * 创建条件变量
     */
    public Condition newCondition() {
        //基于sync实现
        return sync.newCondition();
    }
}