深入理解ReentrantLock重入锁
ReentrantLock
公平性锁和非公平性锁
非公平性：如果一个线程因为CPU时间全部被其他的线程抢走而无法获得CPU的执行时间，这种状态称之为饥饿，而该线程被称为“饥饿致死”，非公平锁就存在“饥饿”，因为线程得不到CPU的运行时间机会。
Java的线程饥饿原因：
1、高优先级的线程抢夺所有的低优先级的线程CPU时间
2、线程被永久阻塞在一个等待进入同步块的状态
3、线程在等待一个本身也处于永久等待完成的对象（比如调用这个对象的wait方法）
公平性：所有的线程均能公平性的获取到执行的机会
公平性锁的实现：
Lock类转换为公平锁FairLock，原理是：每一个Lock调用的线程都回去进入到队列，当解锁后，只有队列中的第一个线程被允许获取锁
ReentrantLock实现
ReentrantLock是Java中的课重入锁的一种实现，一次只能有一个线程持有锁，也就是独占锁的概念
包含三个内内部类：Sync、NonFairSync、FairSync,公平性锁和非公平性锁通过构造函数来指定
public class ReentrantLock implements Lock, java.io.Serializable {
//默认的非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
//fair决定是公平性锁和非公平性锁 true：公平锁 false：非公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
//加锁
public void lock() {
sync.lock();
}
//非公平性锁实现
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
//释放锁
public void unlock() {
sync.release(1);
}
public Condition newCondition() {
return sync.newCondition();
}
//判断有线程在等待锁
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
}
使用示例
公平锁和非公平锁的不同
A、B两个线程不断的获取共享的变量，为了保证变量的并发安全，分别使用公平锁和非公平锁实现加锁操作
实现类：
public class NonFairAndFairDemo implements Runnable {
private static Integer num = 0;
private ReentrantLock rtl;
public NonFairAndFairDemo(ReentrantLock rtl) {
this.rtl = rtl;
}
@Override
public void run() {
while (true) {
//显性加锁
rtl.lock();
num++;
System.out.println(Thread.currentThread().getName()+":"+num);
//显性释放锁
rtl.unlock();
}
}
}
公平性锁的调用：
公平性锁的执行结果：
非公平锁调用：
非公平性线程执行结果：
注意：Lock锁的使用：
加锁和释放锁是显性调用
加锁和释放锁必须成对出现
多把锁的使用遵循先加锁后释放，后加锁先释放的原则
ReentrantLock的源码分析
ReentrantLock具体实现委托给内部类（Sync、FairSync、NonFairSync）
公平锁个非公平锁的父类Sync：
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
//加锁操作，抽象方法，需要子类FairSync和NonFairSync实现
abstract void lock();
//非公平锁和公平锁都需要调用的方法
final boolean nonfairTryAcquire(int acquires) {
//获取当前的线程
final Thread current = Thread.currentThread();
//获取AQS中state属性值， state = 0：锁空闲， 大于0：锁占用 小于0：锁溢出
int c = getState();
if (c == 0) { //state== 0 表示锁空闲
//通过CAS确保多线程并发操作的安全
if (compareAndSetState(0, acquires)) {//加锁成功
//设置当前持有锁的线程
setExclusiveOwnerThread(current);
return true; //获取锁成功，返回
}
}
//和if相对应的是锁非空闲：当前线程持有锁和其他线程持有锁
else if (current == getExclusiveOwnerThread()) {//当前线程要获取锁
//对持有锁的次数进行变更（+1）
int nextc = c + acquires;
//state是int类型值，有符号的类型 最高位是符号为 1：负数 0：整数
if (nextc < 0) // overflow //被锁次数上溢（很少出现）
throw new Error("Maximum lock count exceeded");
setState(nextc);//当前持有锁的线程变更锁保护的资源
//当前线程是持有锁的线程，获取锁成功， 返回
return true;
}
//锁非空闲，但持有锁的线程不是当前线程
return false;
}
//释放
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;
//c==0，真正释放锁，将持有锁的线程信息置为null
setExclusiveOwnerThread(null);
}
//变更锁的状态
setState(c);
//当释放锁是 ，c==0时真正释放锁，c不等于0，只是将锁状态变更，不会真释放锁
return free;
}
//释放当前线程持有锁
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
//获取Condition对象
final ConditionObject newCondition() {
return new ConditionObject();
}
//获取持有锁的线程
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
//加锁次数
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
//释放加锁，通过state判断加锁
final boolean isLocked() {
return getState() != 0;
}
}
公平锁的实现：FairSync
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
final void lock() {
acquire(1);
}
//公平锁实现的tryAcquire
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {//锁是空闲的
//当前线程处于等待队列的第一个等待着或者等待队列为空时，当前的线程才能获取锁
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");
//变更state值
setState(nextc);
return true;
}
return false;
}
}
AQS类中方法：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
//获取锁失败时，当前线程加入到等待队列
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
//当前线程是否处于对队列第一个或者是当前队列为null
public final boolean hasQueuedPredecessors() {
Node t = tail; // Read fields in reverse initialization order
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}
非公平性锁：NonFairSync
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
//lock加锁操作
final void lock() {
if (compareAndSetState(0, 1)) //直接通过CAS抢锁，true：抢锁成功
setExclusiveOwnerThread(Thread.currentThread());//设置锁的持有者
else
acquire(1); //获取锁失败，进入到常规流程，acquire会首先调用tryAcquire
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
AQS的：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
重入锁的实现：
1、重入锁（ReenTrantLock）的实现内部包含Sync、NonFairSync、FairSync内部类
2、重入锁实现重入计数使用AQS色state属性，state大于0表示锁被占用，等于0表示锁空闲，小于0计数太多导致溢出
3、重入锁必须持有对锁持有者的引用，一次判断是否可以重入
Condition
ReentrantLock提供了线程间通信的机制，借助于Condition对象，更具有灵活性
newCondition方法：
public Condition newCondition()
返回一个Condition实例，实例需要结合Lock锁实例一起使用
Condition接口方法：
public interface Condition {
//使当前的线程进入休眠进行等待，类似于wait()
void await() throws InterruptedException;
void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
//唤醒因await进入休眠的一个线程，类似于notify
void signal();
//唤醒因await进入休眠的所有线程，类似于notifyAll
void signalAll();
}
注意：
- Condition实例的通信方法是需要和Lock实例结合一块使用
- Condition实例必须是有当前的Lock实例创建的，否则会抛出IllegalMonitorStateException
- await和signal必须作用于同一个Condition实例，通信才能被接收
- await和signal/signalAll使用必须进行加锁（Lock实例，显性的进行加锁释放锁）
使用实例
public class ConditionDemo {
//锁实例
static ReentrantLock lock = new ReentrantLock();
//Condition实例
static Condition condition = lock.newCondition();
static class AwaitTh extends Thread {
@Override
public void run() {
lock.lock();
long millis = System.currentTimeMillis();
try {
condition.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
long l = System.currentTimeMillis() - millis;
System.out.println(Thread.currentThread().getName()+"耗时："+l);
lock.unlock();
}
}
static class SignalDemo extends Thread {
@Override
public void run() {
lock.lock();
try {
//休眠5秒
Thread.sleep(10000);
System.out.println(Thread.currentThread().getName()+"发送通知");
condition.signal();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}
public static void main(String[] args) {
new AwaitTh().start();
new SignalDemo().start();
}
}
Condition与Object提供的wait、notify、notifyAll的区别
相同点：都可以进行线程间通信，Condition中的await方法相当于Object的wait方法，Condition中的signal方法相当于Object的notify方法,…
不同点：
1、Object中的通信方法是和同步锁捆绑使用（Synchronized）、Condition需要使用互斥锁、共享锁（Lock实例）
2、Condition能更加精细的控制多线程的休眠和唤醒，对于同一个锁，可以创建多个Condition，在不同的情况加使用不同的Condition