简单看看ReentrantLock

　　前面我们分析了AQS的基本原理，然后也试着基于AQS实现了一个可重入的锁了，现在我们再来看看官方的ReentrantLock锁，这个锁是可重入的独占锁，也就是说同时只有一个线程可以获取该锁，而且这个线程还能继续尝试获取锁；

一.简单的使用

　　我们先根据ReentrantLock来简单实现一个线程安全的List，然后再分析常用的方法；

package com.example.demo.study;

import java.util.ArrayList;
import java.util.concurrent.locks.ReentrantLock;

public class Study0204 {
    //线程不安全的List
    private ArrayList<String> list = new ArrayList<String>();
    //独占锁,默认是非公平锁，传入true可以是公平锁
    private volatile ReentrantLock lock = new ReentrantLock();

    //往集合中添加元素
    public void add(String str) {
        lock.lock();
        try {
            list.add(str);
        } finally {
            lock.unlock();
        }
    }
    //删除集合中的元素
    public void remove(String str) {
        lock.lock();
        try {
            list.remove(str);
        } finally {
            lock.unlock();
        }
    }
    //根据索引获取集合中某个元素
    public String get(int index) {
        lock.lock();
        try {
            return list.get(index);
        } finally {
            lock.unlock();
        }
    }
}

　　其实就是在每一步都会进行一个加锁的过程，用法和synchronized关键字一样，但是要注意一定要在finally中释放锁，而且不知道大家有没有发现一个问题，在get方法中，需要用锁吗？为什么多线程去读数据也要加锁呢，又没有改变集合中的数据，这也是ReentrantLock这个锁的一个缺陷，使用于写多读少的情况；

　　所以后面我们会说一下ReentrantReadWriteLock这个锁，这个锁应用于读多写少的情景，可以把读锁和写锁分开使用，如果是读数据可以多个线程都可以获取读锁，后面会说到的

二.看看ReentrantLock锁结构

　　这个锁其实也很简单，下图所示：实现Lock接口，还有一个内部工具类Sync继承自AQS，然后还有两个类NonfairSync和FairSync继承Sync实现自己的方法，看名字就知道这两个类其实就是非公平锁和公平锁的实现策略；

　　首先我们看看ReentrantLock的lock方法，发现就是调用sync的lock方法，所以下一步我们看看这个sync对象是怎么构建出来的；

　

　　看看构造器，可以知道根据传入的参数是true和false构建sync对象是公平策略还是非公平策略；顺便一说，在这里AQS中的state表示的是锁的可重入次数，默认情况state为0；

　　当第一次一个线程CAS成功获取了该锁，那么state就加一，当这个已经获取该锁的线程继续获取锁，state继续加一，释放锁state就减一，直到变为0，那么说明该锁就没有线程占有了，此时AQS中阻塞队列中的某个线程就可以获取锁了；

　　我们可以看看这里的Sync实现了一些什么方法，下图所示，只有lock()方法没有实现，留给NonfairSync和FairSync各自根据自己的场景去实现；

　　公平锁策略实现如下，实现了lock方法还有tryAcquire()方法，其中这个tryAcquire方法以前说活是AQS中特意留给子类根据实际场景去实现的

　　非公平策略实现如下，和公平策略实现的方法一样；

三.非公平策略获取锁

　　前面说了ReentrantLock的基本结构，然后我们分析看看是怎么获取锁的，从NonfairSync中的lcok方法开始，我们梳理一下：首先当前线程A使用CAS尝试将AQS中的state从0设置为1，如果成功，那就直接将当前线程设置为锁的占有者；失败的话，那就去获取state的值，如果为0，还是用CAS设置为1，将当前线程设置为锁的占有者，不为0，那就看看占有锁的是不是当前线程；如果是当前线程，就将state加一；不是当前线程，那就是其他线程占用该锁，这才真正说明当前线程获取锁失败，我们才将当前线程封装成一个Node.EXCLUSIVE类型的节点，丢到阻塞队列中去；

　　这里我们需要想一下为什么说这里是非公平的？假如在下面nonfairTryAcquire方法中，线程A获取到的c的值为1，占有锁的不是线程A，那么线程就被封装成节点丢到阻塞队列中去了，这个时候线程B来获取c的值，刚好是0（因为这个时候可能那个占有了该锁的线程释放了锁），于是线程B就能成功的将state从0变为1，能获得该锁；

　　虽然线程A先尝试获取该锁，线程B后去获取，然而线程B居然可以先成功获取到锁，就好像你排队吃饭，一个后来的人居然先打到饭去吃了，真的是日了狗了！

final void lock() {
    //尝试通过CAS将state从0改为1，如果成功那就将当前线程占用该锁
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    //CAS失败，说明有其他线程已经获取锁了，于是就将当前线程丢到阻塞队列中去，重点看看acquire方法
    else
        acquire(1);
}

//主要看tryAcquire方法，在NonfairSync中实现
//当前方法中，if判断中第二个条件已经看过了，主要是将当前线程封装成一个Node.EXCLUSIVE类型的节点
//然后丢到阻塞队列的最后面去
public final void acquire(int arg) {
    if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

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

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    //获取state的值
    int c = getState();
    //state的值位0的话，那就CAS设置为1，并且设置当前线程占用该锁
    if (c == 0) {
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //CAS设置失败，肯定有其他线程占用该锁，由于是可重入锁，所以这里先判断占有该锁的是不是当前线程
    else if (current == getExclusiveOwnerThread()) {
        //是，那就将state加一
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    //能到这里，说明state的值不是0，占有锁的也不是当前线程，肯定是其他线程，那就返回false
    return false;
}

四.公平策略获取锁

　　其实公平策略和非公平策略的实现基本一样，我们只看看tryAcquire方法的实现：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        //重点是这里不同，不会直接去通过CAS获取锁，而是调用hasQueuedPredecessors方法查看阻塞队列中有没有前驱节点,
        //这个方法是核心，如果阻塞队列中当前线程节点的前面有节点，那么这里不会进去，直接会走下面的else if
        //如果前面没有节点，那么说明当前阻塞队列为null或者只有当前线程这一个节点，那就可以获取CAS修改state，获取锁成功
        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;
}

//判断阻塞队列中当前线程节点前面有没有节点？
public final boolean hasQueuedPredecessors() {

    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    //注意，头节点head指向的是哨兵节点
    //如果头节点和尾节点一样即h==t，前面博客画图都说了都指向哨兵节点，此时阻塞队列为空，没有前驱节点，就返回false
    //如果h != t同时(s = h.next) == null，说明阻塞队列中哨兵节点后面正在插入一个节点，此时表示有前驱节点，返回true
    //如果h != t同时(s = h.next) != null，而且s.thread != Thread.currentThread()，说明哨兵节点后面有一个节点，而且这个节点还不是当前线程节点
    //也就是说有前驱节点，返回true
    return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
}

五.其他一些方法

　　上面我们看了公平策略和非公平策略的实现方式，其实没什么，比较容易，继续看看一些其他的方法，这些方法是通用的；

　　1.lockInterruptibly()方法

//前面说过加了Interruptibly表示如果当前线程在调用该方法时，其他线程调用了当前线程的interrupt()方法的时候，那么
//当前线程就会抛出InterruptedException异常，我们可以看看内在的机制是怎么实现的
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

public final void acquireInterruptibly(int arg) throws InterruptedException {
    //如果当前线程被中断，就抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    //尝试获取资源，这里分为公平策略和非公平策略，前面已经说过了;
    //获取资源失败的话，就调用AQS可被中断的方法
    if (!tryAcquire(arg))
        doAcquireInterruptibly(arg);
}

　　2.tyLock()方法

//很明显这个tryLock方法是非公平策略
public boolean tryLock() {
    return sync.nonfairTryAcquire(1);
}
//这个方法在前面说非公平策略的时候tryAcquire方法调用的也是这个方法
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;
}

　　

　　3.tryLock(long timeout, TimeUnit unit)方法

　　这个方法和上面的方法不一样的就是可以设置超时时间，其实和前面说的也差不多，就是多了一个时间的判断，这个也是会对线程中断有响应的；

public boolean tryLock(long timeout, TimeUnit unit)
        throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}

public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}

　　4.unlock()释放锁

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

public final boolean release(int arg) {
    //从下面的方法我们可以知道tryRelease只有当state为0的时候才会返回true，也就是当前锁没有被线程持有
    //此时，如果头节点不为null，而且头节点的waitStatus不为初始状态，就唤醒头节点
    if (tryRelease(arg)) {
        Node h = head;
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

protected final boolean tryRelease(int releases) {
    //将AQS中的state减一
    int c = getState() - releases;
    //当前线程如果不是锁的拥有者，却调用了unlock方法，那么就会抛出IllegalMonitorStateException异常
    //在这里就能判断了如果原先的state为0，那么上面的c应该就是负一，就会走到这里来抛错，如果state为1，就会到下面的if(c==0)里面
    //如果state大于1，那么只会到最下面的setState(c)将减一之后的state更新到AQS中
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    //可重入数字为0，就将当前持有锁的线程设置为null
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    //这里不管重入数字是不是0，我们只会将最新的state更新获取
    setState(c);
    return free;
}

六.总结

　　我们已经看到了ReentrantLock这个锁的基本功能，其实就是一个独占锁，而且是可重入的，这里的重入指的是一个已经占有了该锁的线程，还可以继续获取该锁！

　　下图所示，同时有三个线程去争夺ReentrantLock锁，此时，只有Thread1成功占有锁了，那么其他的两个线程就被丢到AQS阻塞队列中去了(这里是有顺序的，先是Thread2，然后是Thread3)；

　　如果这个时候Thread1调用了条件变量1的await方法，那么Thread1就被丢到条件队列1中，并且释放锁，这个时候阻塞队列中就会有一个线程可以获取锁，如果是公平锁，那么就是阻塞队列中最前面的那一个获取锁，此时阻塞队列中只有Thread3了；（如果是非公平锁，那么就是看运气，Thread2和Thread那个先去尝试获取锁那么就获得锁）