Jdk1.6 JUC源码解析(7)

时间:2021-02-03 17:55:52
功能简介:
  • Java代码层面提供的锁机制,可做为Synchronized(jvm内置)的替代物,和Synchronized一样都是可重入的。
  • 与Synchronized相比较而言,ReentrantLock有以下优 势:支持公平/非公平锁、支持可中断的锁、支持非阻塞的tryLock(可超时)、支持锁条件、可跨代码块使用(一个地方加锁,另一个地方解锁),总之比 Synchronized更加灵活。但也有缺点,比如锁需要显示解锁、无法充分享用JVM内部性能提升带来的好处等等。
源码分析:
  • ReentrantLock实现了Lock接口,先来看下这个接口:
public interface Lock {
/**
* 获取锁,如果锁无法获取,当前线程被阻塞,直到锁可以获取并获取成功为止。
*/
void lock();
/**
* 在当前线程没有被中断的情况下获取锁。
* 如果获取成功,方法结束。
* 如果锁无法获取,当前线程被阻塞,直到下面情况发生:
* 1.当前线程(被唤醒后)成功获取锁。
* 2.当前线程被其他线程中断。
*/
void lockInterruptibly() throws InterruptedException;
/**
* 如果当前锁是可用的,获取锁。
* 获取成功后,返回true。
* 如果当前锁不可用,返回false。
*/
boolean tryLock();
/**
* 如果锁在给定超时时间内可用,并且当前线程没有被中断,那么获取锁。
* 如果锁可用,获取锁成功并返回true。
* 如果锁无法获取,当前线程被阻塞,直到下面情况发生:
* 1.当前线程(被唤醒后)成功获取锁。
* 2.当前线程被其他线程中断。
* 3.指定的等待时间超时。
*/
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
/**
* 释放锁。
*/
void unlock();
/**
* 返回一个和当前锁实例相关联的条件。
* 当前线程必须首先获取锁后才能在锁条件上等待。
* 一个Condition的await()方法调用会在等待之前自动释放锁,在等待结束
* 前重新获取锁。
*/
Condition newCondition();
}
  • 之前分析AQS的时候提到过,基于AQS构建的同步机制都会使用内部帮助类继承AQS的方式构建,看下ReentrantLock中的同步机制:
    //内部同步机制的引用。
private final Sync sync;
/**
* 这个锁实现的基本同步控制机制,下面会提供公平和非公平版本的子类。
* 利用AQS的state来表示锁持有(重入)的次数。.
*/
static abstract class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
/**
* Performs {
@link Lock#lock}. The main reason for subclassing
* is to allow fast path for nonfair version.
*/
abstract void lock();
/**
* 方法用来支持非公平的tryLock
*/
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//如果当前没有任何线程获取锁(锁可用),尝试设置state。
if (compareAndSetState(0, acquires)) {
//如果设置成功,将当前线程信息设置到AQS中(所有权关联)。
setExclusiveOwnerThread(current);
return true;
}
}
//如果锁已经被持有,那么判断一下持有锁的线程是否为当前线程。
else if (current == getExclusiveOwnerThread()) {
//如果是当前线程在持有锁,那么这里累计一下重入次数。
int nextc = c + acquires;
if (nextc < 0) // overflow 重入次数最大不能超过int的最大值
throw new Error("Maximum lock count exceeded");
//设置到AQS的state中
setState(nextc);
return true;
}
//如果锁已经被持有,且持有线程不是当前线程,返回false。
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) {
//如果当前线程完全释放了锁(重入次数为0)
free = true;
//解除所有权关系。
setExclusiveOwnerThread(null);
}
//设置重入次数。
setState(c);
//返回是否释放成功(或者说是否完全释放)。
return free;
}
protected final boolean isHeldExclusively() {
// While we must in general read state before owner,
// we don't need to do so to check if current thread is owner
return getExclusiveOwnerThread() == Thread.currentThread();
}
final ConditionObject newCondition() {
return new ConditionObject();
}
// Methods relayed from outer class
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
final boolean isLocked() {
return getState() != 0;
}
/**
* Reconstitutes this lock instance from a stream.
*
@param s the stream
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(
0); // reset to unlocked state
}
}

       接下来先看一下非公平版本的子类:

    /**
* Sync object for non-fair locks
*/
final static 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() {
//这里首先尝试一个短代码路径,直接CAS设置state,尝试获取锁。
//相当于一个插队的动作(可能出现AQS等待队列里有线程在等待,但当前线程竞争成功)。
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(
1);//如果CAS失败,调用AQS的独占请求方法。
}
protected final boolean tryAcquire(int acquires) {
//调用上面父类的nonfairTryAcquire方法。
return nonfairTryAcquire(acquires);
}
}

       再来先看一下公平版本的子类:

    /**
* Sync object for fair locks
*/
final static 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)) { //如果当前锁可用,且同步等待队列中没有其他线程,那么尝试设置state
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;
}
}
       小总结一下:        非公平版的锁-加锁操作
  1. 当前线程首先会无条件的执行一个CAS操作来获取锁,如果CAS操作成功,获取锁成功。
  2. 如果第1步没成功,当前会检查锁是否被其他线程持有,也就是锁是否可用。
  3. 如果没有其他线程持有锁,会以CAS的方式尝试获取锁,如果CAS操作成功,获取锁成功。
  4. 如果有其他线程持有锁,会判断一下持有锁的线程是否为当前线程,如果是当前线程,重入次数+1,获取锁成功。
  5. 根据AQS的分析,上述2、3、4步会执行多次,如果最终获取锁失败,当前线程会被阻塞,等待其他线程执行解锁操作将其唤醒。
       公平版的锁-加锁操作
  1. 当前线程首先会检查锁是否被其他线程持有,并且当前同步等待队列里有没有其他线程在等待。
  2. 如果没有其他线程持有锁,且同步等待队列里没有其他线程,会以CAS的方式尝试获取锁,如果CAS操作成功,获取锁成功。
  3. 如果有其他线程持有锁,会判断一下持有锁的线程是否为当前线程,如果是当前线程,重入次数+1,获取锁成功。
  4. 根据AQS的分析,上述1、2、3步会执行多次,如果最终获取锁失败,当前线程会被阻塞,等待其他线程执行解锁操作将其唤醒。
       非公平版和公平版锁的解锁操作一样
  1. 当前线程首先将锁重入次数减1(AQS的state),如果减1后结果为0,将当前同步器的线程信息置空,并唤醒同步等待队列中队头的等待线程。
  2. 如果第1步中,重入次数减1后结果不为0(说明当前线程还持有当前锁),方法结束。
  • 有了内部的基础同步机制,ReentrantLock的实现就很简单了,直接看代码:
    /**
* 默认情况下构建非公平锁。
*/
public ReentrantLock() {
sync
= new NonfairSync();
}
/**
* 根据给定的公平策略生成相应的实例。
*
*
@param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync
= (fair)? new FairSync() : new NonfairSync();
}

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

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

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

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

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

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

       最后看一下一些支持监测的方法:

    /**
* 获取当前线程的对当前锁的持有(重入)次数。
*/
public int getHoldCount() {
return sync.getHoldCount();
}
/**
* 判断当前锁是否被当前线程持有。
*/
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
/**
* 判断当前锁是否被(某个线程)持有。
*/
public boolean isLocked() {
return sync.isLocked();
}
/**
* 当前锁是否为公平锁。
*/
public final boolean isFair() {
return sync instanceof FairSync;
}
/**
* 获取持有当前锁的线程。
*/
protected Thread getOwner() {
return sync.getOwner();
}
/**
* 判断是否有线程在当前锁的同步等待队列中等待。
*/
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
/**
* 判断给定的线程是否在当前锁的同步等待队列中等待。
*/
public final boolean hasQueuedThread(Thread thread) {
return sync.isQueued(thread);
}
/**
* 获取当前锁的同步等待队列中的等待线程(估计)数量。
*/
public final int getQueueLength() {
return sync.getQueueLength();
}
/**
* 获取当前锁的同步等待队列中等待的线程。
*/
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}
/**
* 判断是否有线程在给定条件的条件等待队列上等待。
*/
public boolean hasWaiters(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.hasWaiters((AbstractQueuedSynchronizer.ConditionObject)condition);
}
/**
* 获取给定条件的条件等待队列中等待线程的(估计)数量。
*/
public int getWaitQueueLength(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitQueueLength((AbstractQueuedSynchronizer.ConditionObject)condition);
}
/**
* 获取给定条件的条件等待队列中等待线程。
*/
protected Collection<Thread> getWaitingThreads(Condition condition) {
if (condition == null)
throw new NullPointerException();
if (!(condition instanceof AbstractQueuedSynchronizer.ConditionObject))
throw new IllegalArgumentException("not owner");
return sync.getWaitingThreads((AbstractQueuedSynchronizer.ConditionObject)condition);
}