ReentrantLock 分析

JUC：Java.util.concurrent 是在并发编程中比较常用的工具类，里面包含很多用来在并发场景中使用的组件。比如线程池、阻塞队列、计时器、同步器、并发集合等等。

lock

​ 定义了释放锁和获得锁的抽象方法，在JDK1.5出现，可以解决synchronized在某些场景下的短板，Lock（可重入，可中断，可公平）比synchronized（可重入，不可中断，不可公平）更加灵活。

ReentrantLock

​ 重入锁：当前线程调用lock获取锁之后，如果方法里面再次调用lock，那么不阻塞，增加重入次数就可以了，这样避免线程死锁的发生。

​ ReentrantReadWriteLock：读写锁，阻塞写，不阻塞读，能够比排它锁提供更好的并发量和吞吐量。

    static HashMap<String, Object> cacheMap = new HashMap<>();
    static ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    static Lock read = rwl.readLock();
    static Lock write = rwl.writeLock();

    /**
     *  读读共享，读写互斥
     */
    public static Object get(String key){
        read.lock();
        try {
            return cacheMap.get(key);
        } finally {
            read.unlock();
        }
    }

    public static void put(String key, Object value){
        write.lock();
        try {
            cacheMap.put(key, value);
        } finally {
            write.unlock();
        }
    }

ReentrantLock 实现原理

​ AQS：全称AbstractQueuedSynchronizer，是一个同步工具也是 Lock 用来实现线程同步的核心组件。

​ AQS内部是一个双向链表，里面由竞争锁失败的节点（Node）组成，每个节点都有指向前驱节点和后继节点的两个指针，其中head和tail节点分别代表队列的首和尾。

​ 竞争锁失败和释放锁：

​ 1，竞争锁失败会将当前线程封装成node，然后他的前驱指向原来的队尾，原来的队尾next指向它，通过cas将tail指向新的尾部节点。

​ 2，释放锁会唤醒head指向的节点，该节点前驱指针指向null，head指向该节点的下一个节点。

ReentrantLock 源码分析加锁

我们的源码分析以非公平锁为例

​ 公平锁：严格按照先进先出的规则获取锁。

​ 非公平锁：新进来的线程总要先争抢一下锁，不管当前队列上是否存在线程等待。

时序图

cas：以乐观所得方式做比较替换。

Node节点的状态

状态	描述
CANCELLED	值为1，由于同步队列中等待的线程等待超时或者是被中断，需要从同步队列中取消等待，节点进入该状态不在变换。
SIGNAL	值为-1，后继节点处于等待状态，而当前节点的线程如果释放了同步状态或者被取消，将会通知后继节点，使后继节点的线程得以运行。
CONDITION	值为-2，节点在等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了signal之后，该节点将会从等待队列中转移到同步队列中，加入到对同步状态的获取。
PROPAGATE	值为-3，表示下一次共享式同步状态的获取将会无条件的传播下去。
INITIAL	值为0，初始状态。

1，NonfairSync.lock()

        final void lock() {
            /**
             *      首先进来争抢锁，cas成功表示获得锁,会调用unsafe.compareAndSwapInt，aqs里面
             *  有个属性state
             *      0：代表无锁状态，
             *      大于0：表示已经有线程获得了锁,由于因为ReentrantLock允许重入，所以同一个线程
             *  多次获得同步锁的时候，state会递增，而释放锁的时候，同样state会递减，直到state=0
             *  才允许其它线程获取锁
             *
             */
            if (compareAndSetState(0, 1))
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1); //cas失败，说明此时state已经不为0，调用acquire(1)走竞争锁逻辑  进入（2）
        }

2，AQS.acquire(int )

        public final void acquire(int arg) {
            /**
             * 1，通过tryAcquire尝试获取独占锁，成功返回true，失败返回false
             * 2，失败会通过addWaiter方法将当前线程封装成Node,添加到AQS的队列尾部
             * 3，acquireQueued 将Node作为参数，通过自旋去尝试获取锁
             */
            if (!tryAcquire(arg) &&
                    acquireQueued(addWaiter(AbstractQueuedSynchronizer.Node.EXCLUSIVE), arg))
                selfInterrupt();
        }

3，NonfairSync.tryAcquire(int )

        //尝试获取锁，成功为true，失败false
		protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }

4，Sync.nonfairTryAcquire(int )

        /**
         * 1，获取当前锁的状态，
         * 2，如果state=0，表示无锁状态，通过cas更新state状态的值获得锁
         * 3，当前线程是属于重入，则增加重入次数
         */
        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;
        }

5，AQS.addWaiter(Node )

        /**
         * 1，将当前线程封装为Node，
         * 2，判断队尾节点是否为空，不为空通过cas将node替换为tail节点
         * 3，为空将节点通过自旋的方式加入AQS队尾
         */
        private AbstractQueuedSynchronizer.Node addWaiter(AbstractQueuedSynchronizer.Node mode) {
            AbstractQueuedSynchronizer.Node node = new AbstractQueuedSynchronizer.Node(Thread.currentThread(), mode);
            AbstractQueuedSynchronizer.Node pred = tail;
            if (pred != null) {
                node.prev = pred;
                if (compareAndSetTail(pred, node)) {
                    pred.next = node;
                    return node;
                }
            }
            enq(node);
            return node;
        }

6，AQS.acquireQueued(Node, int)

​ 通过addWaiter将线程添加到AQS队列后，接着会将该节点传入acquireQueued方法去竞争锁

        /**
         * 1，获取当前线程的前驱节点，
         * 2，如果是head节点，那么它就有资格获取锁，调用tryAcquire去争抢锁并且移出原来的head节点，head指向当前节点
         * 3，否则，根据waitstatus去挂起线程
         * 4，通过cancelAcquire取消获得锁的操作
         */
        final boolean acquireQueued(final AbstractQueuedSynchronizer.Node node, int arg) {
            boolean failed = true;
            try {
                boolean interrupted = false;
                for (;;) {
                    final AbstractQueuedSynchronizer.Node p = node.predecessor();
                    if (p == head && tryAcquire(arg)) {
                        setHead(node);
                        p.next = null; // help GC
                        failed = false;
                        return interrupted;
                    }
                    if (shouldParkAfterFailedAcquire(p, node) &&
                            parkAndCheckInterrupt())
                        interrupted = true;
                }
            } finally {
                if (failed)
                    cancelAcquire(node);
            }
        }

LockSupport：Java6引入的一个类，提供了基本的线程同步原语，park和unpark，unpark就像提供许可，park就像等待许可，但是这个许可是一次性的，不可叠加的，既调用unpark多次结果是一样的只够park消费一次。如果线程park阻塞了，这时候调用interrupt()方法会发起中断，然后在调用unpark方法，但是不抛出异常，只调用unpark方法只是会唤起park并不会有中断信号。

ReentrantLock 源码分析释放锁

1，AQS.release(int )

    public final boolean release(int arg) {
        if (tryRelease(arg)) {		//如果释放锁成功
            Node h = head;
            //如果head节点不为空，则唤醒后续节点
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

2，Reentrant.tryRelease(int )

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

3，AQS.unparkSuccessor(Node )

    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;		////获得 head 节点的状态
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);	// 设置 head 节点状态为 0

        Node s = node.next;	//得到 head 节点的下一个节点
        //如果下一个节点为 null 或者 status>0 表示 cancelled 状态
        if (s == null || s.waitStatus > 0) {
            s = null;
            //通过从尾部节点开始扫描，找到距离 head 最近的一个waitStatus<=0 的节点
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)	//next 节点不为空，直接唤醒这个线程即可
            LockSupport.unpark(s.thread);
    }