一、简介
众所周知，Java并发组件中的一个重要框架就是AQS，简称同步器。全称AbstractQueuedSynchronizer，它是基于模板方法模式实现的。也就是说大体算法框架已经写好了，具体的一些细节需要用户去实现。AQS中有5个方法是用户根据需要实现的(排它锁与否)：
protected boolean tryRelease(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {
throw new UnsupportedOperationException();
}
protected boolean isHeldExclusively() {
throw new UnsupportedOperationException();
}二、ReentrantLock的骨架
ReentrantLock是排它锁，需要实现上面的两个排它方式的方法。看一下ReentrantLock的内部构造：
ReentrantLock锁依赖于Sync:
public class ReentrantLock implements Lock {
...
private final Sync sync;
...
}并在内部实现了Sync:
abstract static class Sync extends AbstractQueuedSynchronizer {
abstract void lock();
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//c = 0 的时候直接获取锁，非公平的，没有去查看队列前面
//还有没有其他线程在获得锁
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//可重入获取锁
else if (current == getExclusiveOwnerThread()) {
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){...}
protected final boolean isHeldExclusively() {...}
...
}分析：
ReentrantLock 是独占锁，按理说需要实现抽象类 AbstractQueuedSynchronizer 中的以下两种方法: tryRelease 和tryAcquire。
从上面可以看出，它只实现了其中一个，接着往下看可以发现，tryAcquire(int arg) 在子类中实现了。Sync有两个子类，分别是：
static final class NonfairSync extends Sync {...}
static final class FairSync extends Sync {...}即非公平锁和公平锁的组件。
1、非公平锁：
static final class NonfairSync extends Sync {
/**
* 1）首先基于CAS将state（锁数量）从0设置为1，如果设置成功，
* 设置当前线程为独占锁的线程；-->请求成功-->第一次插队
* 即在尝试的过程中，已经被其他线程先一步占有了锁)，
* 这个时候当前线程执行acquire(1)方法
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}分析：
Sync默认实现了非公平锁获取的方法。在NonfairSync中，实现了boolean tryAcquire(int acquires)，即以非公平的方式获取锁。上面的acquire(1)函数在AQS中已经实现了，其中就调用了这里实现的boolean tryAcquire(int acquires)方法。
2、公平锁：
static final class FairSync extends Sync {
final void lock() {
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
//c为0的时候可以获取锁
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");
setState(nextc);
return true;
}
return false;
}
}分析：
在FairSync中，实现了boolean tryAcquire(int acquires)，即以公平的方式获取锁。注意和 Sync 中的 final boolean nonfairTryAcquire(int acquires) 作比较。Lock()里面的acquire(1)函数在AQS中已经实现了，其中就调用了这里实现的boolean tryAcquire(int acquires)方法。
好了，至此上面所说的两个函数都实现了: tryRelease，tryAcquire。
三、具体实现
既然Sync组件已经写好了，那么ReentrantLock中的方法就可以使用它了。上面说到，ReentrantLock依赖组件Sync，即：
public class ReentrantLock implements Lock {
...
private final Sync sync;
...
}下面看一下ReentrantLock的具体实现：
1、构造函数：有两个，默认是非公平的。
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}2、获得锁：
//不响应中断地获取锁
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));
} 3、释放锁
public void unlock() {
sync.release(1);
}4、条件变量
public Condition newCondition() {
return sync.newCondition();
}5、锁相关的工具性质的方法
//当前锁被当前线程持有的次数
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;
}
//返回持有该锁的线程，没有的话返回null
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();
}6、条件变量相关工具类方法
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);
}四、最后
可以看到，ReentrantLock方法的实现全部是依靠Sync的方法。而Sync又是继承了AQS，所以重点就是分析AQS。
这篇文章只是分析个大概，并没有去详细剖析，主要是为了了解ReentrantLock的大致结构，掌握大局。
扫一扫
34
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
