ReentrantLock初步认识
ReentrantLock是可重入的独占锁,同时只能有一个线程可以获取该锁,其他获取该锁的线程会被阻塞而放入该锁的AQS阻塞队列里面。如果当前获得该锁的线程再次获取该锁,则会记录重入次数。
ReentrantLock的类图如下:
从类图可以看到,ReentrantLock最终还是使用AQS来实现的,通过构造函数的参数来决定其内部是一个公平锁还是非公平锁,默认是非公平锁。
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
其中Sync内部类直接继承自AQS,它的子类NonfairSync和FairSync分别实现了获取锁的非公平与公平策略。
在ReentrantLock中,AQS的state状态值表示线程获取该锁的重入次数,在默认情况下,state的值为0表示当前没有被任何线程持有。当一个线程第一次获取该锁时会尝试使用CAS设置state的值为1,如果CAS设置成功则当前线程获取了该锁,然后记录该锁的持有者为当前线程。在该线程没有释放锁的情况下第二次获取该锁后,状态值被设置为2,这就是可重入次数。在该线程释放该锁时,会尝试使用CAS让状态值减1,如果减1后状态值为0,则当前线程释放该锁。
ReentrantLock基本操作
void lock()方法
当一个线程调用该方法时,说明该线程希望获取该锁。如果锁当前没有被其他线程占用并且当前线程之前没有获取过该锁,则当前线程会获取到该锁,然后设置当前锁的拥有者为当前线程,并设置AQS的状态值为1,然后直接返回。如果当前线程之前已经获取过该锁,则把AQS的状态值加1后返回。如果该锁已经被其他线程持有,则调用该方法的线程会被放入AQS队列后阻塞挂起。
public void lock() {
sync.lock();
}
在如上代码中,ReentrantLock的lock()委托给了sync类,根据ReentrantLock构建函数选择sync类的实现是NonfairSync还是FairSync,这个锁是一个非公平锁或者公平锁。
NonfairSync非公平锁:
final void lock() {
// 使用CAS设置state的状态值
if (compareAndSetState(0, 1))
// 设置线程持有者为当前线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 调用AQS尝试获取锁
acquire(1);
}
在lock方法中,当前线程首先会去修改state的状态值,如果修改成功则设置线程持有者为当前线程。如果修改失败则会调用AQS的acquire()方法尝试获取锁。
public final void acquire(int arg) {
// 调用ReentrantLock重写的tryAcquire方法
if (!tryAcquire(arg) &&
// tryAcquire方法返回false会把当前线程放入AQS阻塞队列
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 当前状态值为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;
}
// 锁已经被其他线程持有,获取锁失败,返回false
return false;
}
在ReentrantLock实现的tryAcquire方法中,首先获得当前的状态值,为0表示该锁没有被其他线程持有,则修改状态值并且设置当前线程为持有者。如果状态不为0,则判断当前线程是否是该锁的持有者,如果是则计入重入次数,如果不是则表示锁已经被其他线程持有,获取锁失败,将当前线程放入AQS阻塞队列。
FairSync公平锁:
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 当前状态值为0,表示该锁没有被其他线程持有
if (c == 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;
}
// 锁已经被其他线程持有,获取锁失败,返回false
return false;
}
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
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());
}
公平锁在获取锁时,会查看当前AQS队列里面是否有比自己更早请求该锁的线程,如果有则返回true,没有则返回false。
void lockInterruptibly()方法
该方法与lock()方法类型,不同点是它对中断进行响应,就是当前线程在调用该方法时,如果其他线程调用了当前线程的interrupt()方法,则当前线程会抛出InterruptedException异常,然后返回。
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public final void acquireInterruptibly(int arg)
throws InterruptedException {
// 如果当前线程被中断,则直接抛出异常
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
// 调用AQS中断
doAcquireInterruptibly(arg);
}
boolean tryLock()方法
尝试获取锁,如果当前该锁没有被其他线程持有,则当前线程获取该锁并返回true,否则返回false。
public boolean tryLock() {
return sync.nonfairTryAcquire(1);
}
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;
}
该代码与非公平锁的tryAcquire()方法代码类是,所以tryLock()使用的时非公平锁策略。
boolean tryLock(long timeout, TimeUnit unit) 方法
尝试获取锁,与tryLock()的不同指出在于,它设置了超时时间,如果超时时间到了并没有获取到该锁则返回false
public boolean tryLock(long timeout, TimeUnit unit)
throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
void unlock()方法
尝试释放锁,如果当前线程持有该锁,则调用该方法会让线程对该线程持有的AQS状态值减1,如果减去1后当前状态为0,则当前线程会释放该锁,否则仅仅减1而已。如果当前线程没有持有该锁而调用了该方法则会抛出IllegalMonitorStateException异常。
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
// 如果不是锁持有者调用了该方法则抛出异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果状态值为0,则清空锁持有者线程
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
案例
package com.wxw.lock;
import java.util.concurrent.locks.ReentrantLock;
public class ReentrantLockDemo {
static ReentrantLock reentrantLock = new ReentrantLock();
static int count = 0;
public static void incr(){
try {
Thread.sleep(100);
reentrantLock.lock();
count++;
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
reentrantLock.unlock();
}
}
public static void main(String[] args) throws InterruptedException {
for (int i = 0; i < 1000; i++){
new Thread(ReentrantLockDemo::incr).start();
}
Thread.sleep(4000);
System.out.println(count);
}
}
ReentrantLock与ReentrantReadWriteLock的区别
解决线程安全问题使用ReentrantLock就可以,但是ReentrantLock是独占锁,只有一个线程可以获取该锁,而实际中会有写少读多的情况,这个时候就可以使用ReentrantRedWriteLock,ReentrantRedWriteLock采用读写分离的策略,允许多个线程可以同时获取读锁。