JUC下的锁-ReentrantLock

ReentrantLock意思为可重入锁，指的是一个线程能够对一个临界资源重复加锁。
借用美团技术博客的一张图说明它和Synchronized的区别

区别
ReentrantLock的主要结构

    ReentrantLock没有直接继承AbstractQueuedSynchronizer，而是Sync继承的。Sync又是个抽象类，有NonfairSync和FairSync两个子类。可以看到默认的构造函数是非公平锁，另一个构造函数则指定公平/非公平。
    全局变量sync在构造函数里被赋值，在加锁、解锁等操作的时候使用sync里面的API

在开始之前要知道公平锁和非公平锁的区别

    公平锁：多个线程按照申请锁的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。
    优点：所有的线程都能得到资源，不会饿死在队列中。
    缺点：吞吐量会下降很多，队列里面除了第一个线程，其他的线程都会阻塞，cpu唤醒阻塞线程的开销会很大
    非公平：多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
    优点：可以减少CPU唤醒线程的开销，整体的吞吐效率会高点，CPU也不必取唤醒所有线程，会减少唤起线程的数量。
    缺点：可能会导致队列中间的线程一直获取不到锁或者长时间获取不到锁，导致饿死。

加锁API

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

FairSync实现

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

        final void lock() {
          // 调用AQS的acquire，AQS的acquire又会调用子类的tryAcquire
            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();
            // 获取AQS的同步状态，如果锁没有被占用（0没占用，1占用），那么获取锁
            if (c == 0) {
                // 如果没有其他线程比当前线程等待的时间更长，那么就把AQS的同步状态置为1
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                     // 设置同步状态成功后，把当前线程设置为独占线程，获取锁成功
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            // 锁被占用，并且是自己占用的话，就加重入次数，否则，获取锁失败返回false
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }

NonfairSync实现

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))
                setExclusiveOwnerThread(Thread.currentThread());
            else // 如果CAS更新同步状态失败再去acquire，acquire又会调用tryAcquire
                acquire(1);
        }

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

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

响应中断获取锁

public void lockInterruptibly() throws InterruptedException {
        // 调用AQS的acquireInterruptibly，如果当前线程没有被中断则获取锁
        sync.acquireInterruptibly(1);
    }

有返回值的获取锁

  public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
  }

 final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            // 没有其他线程获取锁，则将当前线程设置为独享线程，返回true
            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");
                // state设置为重入的层数
                setState(nextc);
                return true;
            }

          // 没拿到锁返回false
            return false;
        }
    }

释放锁API

释放锁是不分公平和非公平的,release是AQS的方法，不允许子类重写。但是其中的tryRelease强制子类重写

public void unlock() {
        sync.release(1);
    }

public final boolean release(int arg) {
        // 释放锁
        if (tryRelease(arg)) { 
            // 如果还有头节点，并且头节点的waitStatus不是初始值，则唤醒后继节点的线程
            Node h = head;
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);
            return true;
        }
        return false;
    }

 protected final boolean tryRelease(int releases) {
            // 当前state-releases=还剩下的重入层数
            int c = getState() - releases;
            // 如果不是当前线程独占，那么不允许当前线程释放锁
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
         
            boolean free = false;
            // 如果重入层数是0了，那么就代表当前线程没锁了，free=true
            if (c == 0) {
                free = true;
                // 清空独占线程
                setExclusiveOwnerThread(null);
            }
            // 设置state，不管state是0还是非0
            setState(c);
            // 返回free
            return free;
        }