ReentrantLock锁

1. 简介

ReentrantLock，可重入锁，是一种递归无阻塞的同步机制。它可以等同于 synchronized 的使用，但是 ReentrantLock 提供了比 synchronized 更强大、灵活的锁机制，可以减少死锁发生的概率

什么是重入锁
释义
广义上的可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁（前提得是同一个对象或者class），这样的锁就叫做可重入锁。ReentrantLock和synchronized都是可重入锁

可重入的好处

1. 可以避免死锁
2. 可以让我们更好的来封装代码

可重入的原理:
重入锁实现可重入性原理或机制是：每一个锁关联一个线程持有者和计数器，当计数器为 0 时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为 1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为 0，则释放该锁

ReentrantLock 还提供了公平锁和非公平锁的选择，通过构造方法接受一个可选的 fair 参数（默认非公平锁）：当设置为 true 时，表示公平锁；否则为非公平锁

公平锁与非公平锁的区别在于，公平锁的锁获取是有顺序的。但是公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量

ReentranLock整体结构如下图:

• ReentrantLock 实现 Lock 接口，基于内部的 Sync 实现。
• Sync 实现 AQS ，提供了 FairSync 和 NonFairSync 两种实现。

2. Lock接口和AQS抽象队列同步器

2.1. Lock抽象方法

在ReentrantLock中实现

2.2. AbstractQueuedSynchronizer

它的队列是怎样实现的? 基于CLH队列实现的

CLH同步队列
  CLH队列是Craig、Landin、Hagersten三人发明的一种基于双向链表数据结构的队列,Java中的CLH队列是原CLH队列的一个变种,线程由原自旋机制改为阻塞机制

这个链表有4个重要的参数

//Node类
volatile Node prev;//上一个
volatile Node next; //下一个
Node nextWaiter; //条件队列 节点信息
volatile Thread thread; //排队的线程
volatile int waitStatus; //线程状态
	 static final int CANCELLED =  1; //表示线程被终止,会被踢出链表
	 static final int SIGNAL    = -1; //信号灯,表示线程正常
	 static final int CONDITION = -2; //该状态的线程,处于条件队列,而非同步队列;条件不满足,线程会被阻塞

2.2.1 什么是条件队列

条件队列,例如ArrayBlockingQueue: 条件不满足,当前线程会进入阻塞

	public void put(E e) throws InterruptedException {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly(); //获得锁
        try {
            while (count == items.length) //但是队列以满
                notFull.await(); //线程进入条件队列且阻塞
            enqueue(e);
        } finally {
            lock.unlock(); //释放锁
        }
    }

3. ReentrantLock

java.util.concurrent.locks.ReentrantLock ，实现 Lock 接口，重入锁。

ReentrantLock 的实现方法，基本是对 Sync 的调用。

3.1. 构造方法

public ReentrantLock() {
    sync = new NonfairSync();
}
//基于参数,创建FairSync还是NonFairSync
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

3.2. lock()

获取锁,调用该方法当前线程将会获取锁,当锁获取后

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

3.3. tryLock

尝试非阻塞的获取锁,调用该方法后立刻返回,如果能够获取则返回true,否则返回false

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

3.4. tryLock(long timeout, TimeUnit unit)

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

超时的获得锁,当前线程在以下3种情况下会返回:

1. 当前线程在超时时间内获得了锁
2. 当前线程在超时时间内被中断
3. 超时时间结束,返回false

3.5. unlock()

释放锁

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

3.6. newCondition()

获取等待通知组件,该组件和当前的锁绑定,当前线程只有获得了锁,才能调用该组件的wait()方法,而调用后,当前线程将释放锁

@Override
public Condition newCondition() {
    return sync.newCondition();
}

ReentrantLock中ConditionObject类和Object类 锁方法区别
ConditionObject类

Condition类的awit()和Object类的wait()方法等效
Condition类的signal()和Object类的notify()方法等效
Condition类的signalAll()和Object类的notifyAll()方法等效

ReentrantLock类可以唤醒指定条件的线程,而Objcet的唤醒是随机的

3.7. lockInterruptibly()

可中断的获取锁,和lock()方法的不同之处在于该方法会响应中断,即在锁的获取中可以中断当前线程

@Override
public void lockInterruptibly() throws InterruptedException {
    sync.acquireInterruptibly(1);
}

4. ReentrantLock与Synchronized的区别

5. Sync 实现类

4.1. FairSync

NonfairSync 是 ReentrantLock 的内部静态类，实现 Sync 抽象类，非公平锁实现类。

5.2. NonfairSync

FairSync 是 ReentrantLock 的内部静态类，实现 Sync 抽象类，公平锁实现类。