java ReentrantLock(可重入锁)初学

学习ReentrantLock,需要先学习 AQS同步器的知识

非公平锁:不一定是完全按照先来先得的顺序来获取资源

公平锁:绝对按照先来先得的顺序获取资源

public class ReentrantLock implements Lock, java.io.Serializable {

private static final long serialVersionUID = 7373984872572414699L;

private final Sync sync;

//继承AQS的抽象类Sync,可以使用AQS已经写好的获取资源和释放资源的方法

abstract static class Sync extends AbstractQueuedSynchronizer {

private static final long serialVersionUID = -5179523762034025860L;

//抽象方法子类来实现

abstract void lock();

//非公平锁尝试获取资源修改 state

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()) {

int nextc = c + acquires;

if (nextc < 0) // overflow

throw new Error("Maximum lock count exceeded");

setState(nextc);

return true;

}

return false;

}

//尝试释放资源,直接减去 releases后state为0代表没有线程占用锁

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;

}

...省略部分代码

}

//非公平锁的实现

static final class NonfairSync extends Sync {

private static final long serialVersionUID = 7316153563782823691L;

//获取锁

final void lock() {

//使用CAS算法修改state(非公平性也主要体现在这里)

if (compareAndSetState(0, 1))

setExclusiveOwnerThread(Thread.currentThread());

else//直接修改失败调用AQS的acquire方法

acquire(1);

}

protected final boolean tryAcquire(int acquires) {

return nonfairTryAcquire(acquires);

}

}

假设有这样一个场景,等待队列中有BC两个线程,此时A线程任务执行结束,释放锁成功,state设置为0,唤醒B线程,与此同时有新的线程D调用lock()获取资源,D线程和B线程进行资源竞争,D线程成功,B又重新挂起,锁被新来的线程获取到,对B来说这是多么不公平的事情(B都等了那么长时间了,也没轮到它),

//公平锁的实现

static final class FairSync extends Sync {

private static final long serialVersionUID = -3000897897090466540L;

final void lock() {

acquire(1);

}

protected final boolean tryAcquire(int acquires) {

final Thread current = Thread.currentThread();

int c = getState();

if (c == 0) {

//state为0的时候要判断等待队列是否为空,等待队列中存在线程,之间返回false,加入队尾,不让 //插队

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;

}

}

//判断队列中是否存在其它等待的线程

public final boolean hasQueuedPredecessors() {

Node t = tail; // Read fields in reverse initialization order

Node h = head;

Node s;

return h != t &&

((s = h.next) == null || s.thread != Thread.currentThread());

}

公平锁的实现主要是在新加入的线程准备获取资源的时候判断一下等待队列中是否存在其它线程,要是存在,就直接加入队尾来保证公平性。

参考: 深入浅出ReentrantLock