一、ReentrantLock简介
ReentrantLock是与关键字synchronized对标的一类锁, ReentrantLock除掉实现公平锁、可中断锁外不建议其他场景使用ReentrantLock。 原因1:synchronized经过(无锁->偏向锁->轻量级锁->自旋锁->重量及锁优化性能不比ReentrantLock差,其实ReentrantLock就是一个自旋锁),原因2:ReentrantLock需要自己释放锁使用麻烦。
二、ReentrantLock实现锁类型
功能 | 可重入锁 | 不可重入 | 公平锁 | 非公平锁 | 独占锁 | 可中断锁 |
Synchronized | 支持 | 不支持 | 不支持 | 支持 | 支持 | 不支持 |
ReentrantLock | 支持 | 不支持 | 支持 | 支持 | 支持 | 支持 |
三、各类型锁特点
公平锁:多线程按照申请锁的顺序获取锁,性能差保证顺序。
非公平锁:获取锁顺序和申请锁的顺序无关,大部分的锁都支持非公平锁,性能好。
可重入锁:当一个线程获取资源(锁),别的线程再次获取,不会出现异常(线程等待)。
不可重入锁:当一个线程获取锁后,别的线程无法再次获取锁。(实现需要自定义)
独占锁:一个线程获取资源(锁),其他线程不能获取该资源。(syn,rl都是队列独占锁)
可中断锁:一个线程等待另外一个线程释放资源,超时后不在等待。
四、ReentrantLock源码解读
NonfairSync:非公平锁
FairSync:公平锁
public class ReentrantLock implements Lock, java.io.Serializable {
private static final long serialVersionUID = 7373984872572414699L;
/** 同步器定义 */
private final Sync sync;
/**
* 继承AQS信号状态控制实现锁同步。
* NonfairSync继承Sync实现非公平锁
* FairSync继承Sync实现公平锁
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
/**
* 定义lock接口提供给NonfairSync、airSync实现
*/
abstract void lock();
/**
* 尝试非公平方式获取锁
* 成功返回true失败返回false
*/
final boolean nonfairTryAcquire(int acquires) {
//获取当前线程
final Thread current = Thread.currentThread();
//获取state值,0表示无锁,1表示已经获取锁
int c = getState();
if (c == 0) {
//如果state=0修改为acquires
if (compareAndSetState(0, acquires)) {
//设置当前拥有独占访问的线程
setExclusiveOwnerThread(current);
return true;
}
}
//当前线程等于持有锁线程
else if (current == getExclusiveOwnerThread()) {
//TODO 理解这块需要理解释放流程
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
//尝试释放锁
protected final boolean tryRelease(int releases) {
//释放锁,修改state=0
int c = getState() - releases;
//如果当前线程不等于已持有线程抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//如果state被修改为0说明成功释放锁
if (c == 0) {
free = true;
//持有线程重置为null
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
//判断持有线程是否等于当前线程(判断线程拥有情况)
protected final boolean isHeldExclusively() {
return getExclusiveOwnerThread() == Thread.currentThread();
}
//初始化队列
final ConditionObject newCondition() {
return new ConditionObject();
}
//返回拥有锁的线程
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
//当前线程占有锁的数量,不持有锁为0,否则1
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
//判断当前线程是否持有锁,持有true,不持有false
final boolean isLocked() {
return getState() != 0;
}
/**
* TODO 干什么用?
*/
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
//自动序列化内置对象
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
/**
* 不公平锁实现
*/
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
/**
* 获取锁
*/
final void lock() {
//修改state状态值为1,体现非公平方式获取锁
if (compareAndSetState(0, 1))
//设置当前线程为持有线程
setExclusiveOwnerThread(Thread.currentThread());
else
//修改失败,自旋阻塞方式存入队列
acquire(1);
}
//尝试非公平方式获取锁
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
/**
* 公平锁实现
*/
static final class FairSync extends Sync {
private static final long serialVersionUID = -3000897897090466540L;
//公平方式获取锁
final void lock() {
//公平方式获取锁,直接加入轮询队列,线程排队
acquire(1);
}
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//AQS方法 TODO
if (!hasQueuedPredecessors() &&
//修改state=0为acquires
compareAndSetState(0, acquires)) {
//设置当前线程为持有线程
setExclusiveOwnerThread(current);
return true;
}
}
//TODO 待理解
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 ReentrantLock() {
sync = new NonfairSync();
}
/**
* 实例化锁类型
* true:公平锁
* false:非公平锁
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
//获取lock
public void lock() {
sync.lock();
}
/**
* 获取锁
* 如果该锁没有被另一个线程保持,则获取该锁并立即返回,将锁的保持计数设置为 1
* 如果当前线程已经保持该锁,则将保持计数加 1,并且该方法立即返回
* 如果该锁被另一个线程保持,则出于线程调度的目的,禁用当前线程,并且在获得锁之前,该线程将一
* 直处于休眠状态,此时锁保持计数被设置为 1
* 备注:锁计数由tryAcquire实现
*/
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
/**
*尝试获取锁成功返回true失败返回false
*/
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
/**
* 超时等待的方式获取锁,如果超时未获取返回false
* 源码解读:AQS源码分析
*/
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
/**
* 锁释放
* 源码解读:AQS源码分析
*/
public void unlock() {
sync.release(1);
}
//初始化队列
public Condition newCondition() {
return sync.newCondition();
}
//当前线程占有锁的数量,不持有锁为0,否则1
public int getHoldCount() {
return sync.getHoldCount();
}
//判断持有线程是否等于当前线程(判断线程拥有情况)
public boolean isHeldByCurrentThread() {
return sync.isHeldExclusively();
}
//判断当前线程是否持有锁,持有true,不持有false
public boolean isLocked() {
return sync.isLocked();
}
//判断当前锁是公平锁,是返回true
public final boolean isFair() {
return sync instanceof FairSync;
}
//返回拥有锁的线程
protected Thread getOwner() {
return sync.getOwner();
}
/**
*是否有线程等待排队获取锁,是返回true
*源码解读:AQS源码分析 TODO
*/
public final boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
/**
* 查询指定线程是否在等待获取锁
* 源码解读:AQS源码分析 TODO
*/
public final boolean hasQueuedThread(Thread thread) {
return sync.isQueued(thread);
}
/**
* 查询等待获取锁的线程数
* 源码解读:AQS源码分析 TODO
*/
public final int getQueueLength() {
return sync.getQueueLength();
}
/**
* 返回等待获取锁的线程集合
* 源码解读:AQS源码分析 TODO
*/
protected Collection<Thread> getQueuedThreads() {
return sync.getQueuedThreads();
}
/**
* 判断是否有线程在condition队列等待
* 源码解读:AQS源码分析 TODO
*/
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);
}
/**
* 判断在condition队列等待的线程数量
* 源码解读:AQS源码分析 TODO
*/
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);
}
/**
* 返回在condition队列等待的线程集合
* 源码解读:AQS源码分析 TODO
*/
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);
}
public String toString() {
Thread o = sync.getOwner();
return super.toString() + ((o == null) ?
"[Unlocked]" :
"[Locked by thread " + o.getName() + "]");
}
}
参考文档: