ReentrantLock-公平锁、非公平锁、互斥锁、自旋锁

　　重入锁，又称递归锁，是指在同一线程中，外部方法获取锁后，内层递归方法仍然可以获取该锁。如果锁不具备重入性，那么当一个线程两次获取锁的时候就会发生死锁。java提供了java.util.concurrent.ReentrantLock来解决重入锁问题。

　　ReentrantLock重入锁并不是容器集合类的一部分，但它在Concurrency包中占据了非常重要的一部分。在并发容器的实现中被大量使用。

　　ReentrantLock是一种显式锁，与synchronized隐式锁对应。synchronized不能显式的对Lock对象进行操作，因此有很多不便利性。而显式锁提供了多种方法来操作Lock。

　　1)       lock()：获取锁，如果锁不可用，那么当前线程会休眠直到获取锁为止。

　　2)       lockInterruptibly()：可中断地获取锁，如果当前线程发生interrupt，则释放锁。

　　3)       tryLock()：尝试获取锁，如果取到了，那么返回true，它与lock()的区别在于它不会休眠当前线程。

　　4)       unlock()：释放锁。

　　5)       newCondition()：创建一个当前锁的条件监视器Condition，condition实例用于控制当前Lock的线程队列的notify和wait。

　　ReentrantLock的实现基于AQS，通过tryAcquire和tryRelease的重写，实现了锁机制和重入机制。

1，ReentrantLock的公平锁与非公平锁

　　ReentrantLock在底层有两种实现方式，分别是FairSync(公平锁)和NonfairSync(非公平锁)，它们lock()流程如图：

 

FairSync

static final class FairSync extends Sync {
    private static final long serialVersionUID = -300003432432432L;
    final void lock() {
        //FairSync直接调用acquire方法来获取锁
        acquire(1);
    }
    protected final boolean tryAcqure(int acquires) {...}
}

　　FairSync与NonfairSync都会调用同样的acquire方法，因此有必要了解一下acquire方法的实现：

public final void acquire(int arg) {
    //只需要注意tryAcquire()方法，它用于请求锁，返回true时后续的操作不再被处理
    if(!tryAcquire(arg) && acquireQueued(addWaiter(Node, EXCLUSIVE)， arg)) {
        selfInterrupt();
    }
}

       tryAcquire用于请求锁，当请求失败的时候，会把当前线程加入等待队列，addWaiter()和acquiredQueued()方法分别对应封装等待线程节点和请求入队操作。

NonfairSync

static final class NonfairSync extends Sync {
    private static final long serialVesionUID = 4324242432L;
    final void lock() {
        //验证当前锁状态，如果是0，那么设置1
        //状态为0说明没有其他线程持有锁，当前线程可以直接获得锁
        //setExclusiveOwnerThread即为了当前排它锁执行所有者线程方法
        if(compareAndSetState(0, 1)) {
            setExclusiveOwnerThread(Thread.currentThread());
        } else {
            //状态不为0，则说明其他线程持有锁，执行获取锁的方法acquire
            //该方法最终用于获取锁的方法是tryAcquire
            acquire();
        }
        
        protected fianl boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }
}

　　1)       NonFairSync类在lock()方法调用的第一时间，直接验证当前锁状态，如果没有其它线程持有锁(锁状态state为0)，那么当前线程会持有锁。NonfairSync与fairSync主要区别为：

　　2)       NonFairSync类的tryAcquire()方法执行不同，它直接调用了nonfairTryAcquire()方法，nonfairTryAcquire()方法不要求严格按照等待队列的入队顺序获取锁。

下面来看一下FairSync.tryAcquire()和NonFairSync.nonfairTryAcquire()：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if(c == 0) {
        //注意这个hasQueuedPredecessors()方法，只有FairSync才会调用它
        //它是FairSync和NonFairSync仅有的区别
        if(!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        } else if(current == getExclusiveOwnerThread()) {...}
        return false;
    }
}

　　1)       FairSync保证了FIFO，先入队的等待线程会先获得锁，而NonfairSync任由各个等待线程竞争。

　　2)       由于FairSync要保证有序性，所以NonfairSync的性能更高，ReentrantLock默认使用NonfairSync。

2，ReentrantLock的重入性

       加锁有两种基本形式，互斥锁与自旋锁。

       互斥锁(Mutex)，通过阻塞线程来进行加锁，中断阻塞来进行解锁。

public class MutexLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();
    private LinkedList<Thread> list = new LinkedList<>();
    public void lock() {
        Thread currentThread = Thread.currentThread();
        //没有任何线程持有锁时，让当前线程持有锁，反之则加入等待队列并阻塞
        if(!owner.compareAndSet(null, currentThread)) {
            waiterQueue.add(currentThread);
            //LockSupport阻塞当前线程
            LockSupport.park();
        }
    }
    public void unlock() {
        //如果解锁的线程不是持有锁的线程，那么抛出异常
        if(Thread.currentThread() != owner.get()) {
            throw new RuntimeException();
        }
        //等待队列里有内容时，恢复队头线程，更改持有锁的线程，反之则直接释放锁
        if(waiterQueue.size() > 0) {
            Thread t = waiterQueue.poll();
            owner.set(t);
            //LockSupport释放指定线程
            LockSupport.unpark(t);
        } else {
            owner.set(null);
        }
    }
}

　　自旋锁(Spin lock)，线程保持运行态，用一个循环体不停地判断某个标质量的状态来确定加锁还是解锁，本质上用一段无意义的死循环来阻塞线程运行。

public class SpinLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();
    public void lock() {
        Thread current = Thread.currentThread();
        //没有任何线程持有锁时，让当前线程持有锁，反之则利用循环来阻塞
        while (!owner.compareAndSet(null, current)) { }
    }
    public void unlock() {
        Thread current = Thread.currentThread();
        //释放锁
        owner.compareAndSet(current, null);
    }
}

       无论哪种实现方式，都回避不了一个问题，那就是在同一个线程中，如果递归地获取相同的锁，都会出现死锁。设想线程A持有了锁，在释放之前，A再次请求加锁，此时由于锁拥有了持有者，于是由于锁拥有了持有者（A自己），于是A被阻塞了。因此需要引入重入锁：       自旋锁(Spin lock)，线程保持运行态，用一个循环体不停地判断某个标质量的状态来确定加锁还是解锁，本质上用一段无意义的死循环来阻塞线程运行。

　　1)       在线程持有锁的时候，其它线程不能访问上锁的共享资源。

　　2)       在线程持有锁的时候，线程本身可以继续访问上锁的共享资源。

　　3)       在多次递归访问中，只有当全部访问都结束了，线程才会释放锁。

　　由此可以想到一个很直观的解决方式——计数器，对持有锁的线程的每一次访问进行计数，只有当访问次数清空之后，其他线程才能继续访问。

public class MutexLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();
    private LinkedList<Thread> waiterQueue = new LinkedList<>();
    private volatile AtomicInteger state = new AtomicInteger(0);
    public void lock() {
        Thread currentThread = Thread.currentThread();
        //如果请求锁的线程是当前线程
        if(owner.get() == currentThread) {
            state.incrementAndGet();
            return;
        }
        //没有任何线程持有锁时，让当前线程持有锁，反之则加入等待队列并阻塞
        if(!owner.compareAndSet(null, currentThread)) {
            waiterQueue.add(currentThread);
            //LockSupport阻塞当前线程
            LockSupport.park();
        }
    }
    public void unlock() {
        //如果解锁的线程不是持有锁的线程，那么抛出异常
        if(Thread.currentThread() != owner.get()) {
            throw new RuntimeException();
        }
        //计数器清空之后才能继续之后的操作
        if(state.get() > 0) {
            state.decrementAndGet();
            return;
        }
        //等待队列里有内容时，释放指定队列，更改持有锁的线程，反之则清空持有锁的线程
        if(waiterQueue.size() > 0) {
            Thread t = waiterQueue.poll();
            owner.set(t);
            //LockSupport释放指定线程
            LockSupport.unpark(t);
        } else {
            owner.set(null);
        }
    }
}

　　FairSync.tryAcquire()和NonfairSync.nofairTryAcquire()有重用部分，无论公平锁还是非公平锁，在处理重入上，代码是一致的：

　　1)       判断state标量是否为0，如果为0，那么说明没有线程持有该锁，当前线程可以持有锁，返回true；FairSync.tryAcquire()和NonfairSync.nofairTryAcquire()有重用部分，无论公平锁还是非公平锁，在处理重入上，代码是一致的：

　　2)       如果state不为0，那么判断当前线程是否为锁持有者。

　　3)       如果不是，那么当前线程不能持有锁，返回false；

　　4)       如果是，那么当前线程已经持有锁，此时认同线程请求次数增加，state需要增加acquires次，acquires表示新增的请求锁次数。

final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if(c == 0) {
        //...
    } else if(current == getExclusiveOwnerThread()) {
        int nextc = c + acquires;
        if(nextc < 0) {
            throw new Error("Maximum lock count exceeded");
        }
        setState(nextc);
        return true;
    }
}

       tryRelease()方法有一个整型参数releases形参，用来表示本次释放锁的次数，如果当前线程不是锁持有者，那么说明这是一次非法调用，当state计数归零的时候，调用setExclusiveOwnerThread(null)，用来表示没有线程持有锁了，此后锁可以被任意调用。

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