1. 简介
ReentrantLock与synchronized关键字一样是可重入的独占锁，不过ReentrantLock提供比synchronized关键字更加灵活的获取锁和释放锁操作，并且支持等待多个条件，但ReentrantLock必须手动释放锁，否则很有可能造成死锁。在JDK6之后，synchronized加入了偏向锁、轻量级锁、自适应自旋、锁粗化、锁消除多种优化措施使它的性能提高了很多，通常情况下表现一般比ReentrantLock好，所以在能使用synchronized功能完成的操作时，尽量不要用ReentrantLock。ReentrantLock中大部分方法是间接调用了AbstractQueuedSynchronizer的方法，所以要想进一步探究其实现可以看看上一篇文章AbstractQueuedSynchronizer源码解析
2. 实现
继承关系
ReentrantLock实现了Lock接口
public class ReentrantLock implements Lock, java.io.Serializable {}
Lock接口提供了锁最基本的几个方法，实现该接口的类都重写了这些方法
public interface Lock {
// 阻塞获取锁
void lock();
// 阻塞获取锁，可响应中断抛出异常
void lockInterruptibly() throws InterruptedException;
// 尝试获取锁
boolean tryLock();
// 尝试在指定时间内获取锁，获取不到则阻塞直到获取到锁返回true或超时返回false
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
// 释放锁
void unlock();
// 创建一个等待条件，获取锁的线程可以等待条件
Condition newCondition();
}
属性
ReentrantLock中最重要的属性就是sync，sync是个实现抽象队列同步器AbstractQueuedSynchronizer抽象方法tryAcquire和tryRelease的类的对象，其中tryAcquire方法决定了是否公平、重入的特性，而tryRelease方法对公平与非公平重入锁都适用。ReentrantLock中方法的实现基本都是调用sync的方法。
private final Sync sync;
Sync类继承关系
Sync
abstract static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -5179523762034025860L;
// 添加抽象方法lock
abstract void lock();
// 添加非公平获取尝试同步状态的方法，该方法体现非公平性与重入特性
final boolean nonfairTryAcquire(int acquires) {
// 获取当前线程
final Thread current = Thread.currentThread();
// 获取当前同步状态
int c = getState();
// 如果没有线程获取同步状态
if (c == 0) {
// 使用CAS方法获取同步状态，这里体现非公平性，因为没有判断等待队列里是否有其他线程在等待获取同步状态
if (compareAndSetState(0, acquires)) {
// 获取成功则设置独占线程
setExclusiveOwnerThread(current);
return true;
}
} // 否则当前线程已经获取过同步状态
else if (current == getExclusiveOwnerThread()) {
// 直接在原基础状态值加上acquires，体现重入性
int nextc = c + acquires;
// 如果nextc小于0表示线程获取锁的次数已经超过最大值
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置新的同步状态
setState(nextc);
return true;
}
return false;
}
// 重写tryRelease方法，对应公平与非公平锁都适用，体现重入性
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;
}
// 判断当前线程是否独占锁
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();
}
// 获取独占锁的线程
final Thread getOwner() {
return getState() == 0 ? null : getExclusiveOwnerThread();
}
// 获取当前线程加锁次数
final int getHoldCount() {
return isHeldExclusively() ? getState() : 0;
}
// 是否已加锁
final boolean isLocked() {
return getState() != 0;
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject();
setState(0); // reset to unlocked state
}
}
### NonfairSync
// 非公平锁
static final class NonfairSync extends Sync {
private static final long serialVersionUID = 7316153563782823691L;
final void lock() {
// 如果当前线程能直接获取同步状态，则设置当前线程为独占线程
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else // 否则再调用acquire获取同步状态
acquire(1);
}
// 重写tryAcquire方法，调用nonfairTryAcquire方法
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
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) {
// 判断等待队列中是否有后继线程，没有再使用CAS方法获取同步状态，
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
// 获取成功设置当前线程为独占线程
setExclusiveOwnerThread(current);
return true;
}
} // 否则当前线程已经获取过同步状态
else if (current == getExclusiveOwnerThread()) {
// 直接在原基础状态值加上acquires，体现重入性
int nextc = c + acquires;
// 如果nextc小于0表示线程获取锁的次数已经超过最大值
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置新的同步状态
setState(nextc);
return true;
}
return false;
}
}
构造函数
// 默认创建非公平锁
public ReentrantLock() {
sync = new NonfairSync();
}
// 根据指定参数创建公平或非公平锁
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
获取锁方法
以下获取锁的方法都是调用Sync类的方法或或从抽象队列同步器继承的方法
// 阻塞获取锁
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);
}
