1、相关类图
可以看到,在
nonfairTryAcquire(int acquires)方法中添加了再次获取同步状态的处理逻辑:通过判断当前线程是否为获取锁的线程来决定获取操作是否成功,如果是获取锁的线程再次请求,则将同步状态值state进行增加并返回true,表示获取成功。
2、ReentrantLock实现分析说明
ReentrantLock重入锁能支持一个线程对资源重复的加锁,而不会把自己锁死。此外,还支持获取锁是的公平和非公平性选择。ReentrantLock
虽然没有像synchronized关键字一样支持隐式的重进入,但是调用lock()方,在已经获取到锁的情况下,能够再次调用lock()方法获取锁,而不被阻塞。
1)实现可重入
实现可重入需要解决两个问题:
1 线程再次获取锁:锁需要识别获取所得线程是否是当前占据锁的线程,如果是,则再次获取到锁
2锁的最终释放:线程重复n次获取锁,随后在第n次释放锁时,其他线程能够获取到锁。因此,锁的释放要求锁对于每次获取都进行计数自增,而在是释放时,计数自减,当计数减为0时,释
放锁。
在AQS里面有一个state字段,通过这个状态记录字段,记录锁获取的次数,它是一个volatile类型的整型值,因此对它的修改可以保证其他线程可以看到。
ReentrantLock通过组合自定义同步器AQS实现锁的获取与释放,可以看到,针对公平锁与非公平锁,分别实现了FairSync和NonfairSync。
构造器:
public ReentrantLock() { //默认是非公平锁
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
获取以及释放同步状态:
内部自定义AQS如下:
abstract static 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();
/**
* Performs non-fair tryLock. tryAcquire is
* implemented in subclasses, but both need nonfair
* try for trylock method.
*/
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
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) {
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();
}
}
tryRelease(int releases)
释放时,通过判断是否是当前线程,如果是,则减少同步状态值,当减为0是,就表示是最终释放,将占用线程设置为null,并设置free为true,返回。
NonfairSync 继承Sync :
static final 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() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
}
)
2)公平获取锁状态
公平与否,是针对获取同步状态而言的,如果锁是公平的,那么锁的获取就应该按照请求的时间顺序,也就是FIFO。
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) {
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;
}
}
可以看到,公平的获取锁多
了判断条件
hasQueuedPredecessors()方法,及加入同步队列中当前节点是否有前驱节点的判断,如果该方法返回true,则表示有线程比当前线程更早的请求获取锁,因此需要等待前驱线程获取并释放锁之后才能继续获取锁。
3、ReentrantLock锁接口方法实现
1)lock(): void
//方法中直接调用自定义同步器sync的lock()
public void lock() {
sync.lock();
}
2) lockInterruptibly(): void
//调用自定义同步器sync的acquireInterruptibly模板方法
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
3)unlock(): void
//调用自定义同步器sync的release模板方法
public void unlock() {
sync.release(1);
}