java的reentrantlock_java的ReentrantLock类详解

最新推荐文章于 2024-10-16 16:42:50 发布

ssslience

最新推荐文章于 2024-10-16 16:42:50 发布

阅读量169

点赞数

文章标签： java的reentrantlock

本文链接：https://blog.csdn.net/weixin_34765773/article/details/114254668

版权

ReentrantLock 能用于更精细化的加锁的Java类, 通过它能更清楚了解Java的锁机制

ReentrantLock 类的集成关系有点复杂, 既有内部类, 还有多重继承关系

![image-20191123213426815](/Users/dasouche/Library/Application Support/typora-user-images/image-20191123213426815.png)

类的定义

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

private static final long serialVersionUID = 7373984872572414699L;

/** Synchronizer providing all implementation mechanics */

private final Sync sync;

..............

实现了 Serializable 接口

实现了Lock接口, Lock 接口中就定义常用的加锁和释放锁的方法. 是一个基本的接口, 很多的锁类都实现了这个方法

sync是它的重要成员变量, 加锁和解锁的操作都是通过这个变量实现的, 这个Sync 是一个静态内部类.

加锁的逻辑

ReentrantLock 的lock方法, tryLock方法和unlock方法

public void lock() {

sync.lock();

}

public void unlock() {

sync.release(1);

}

public boolean tryLock() {

return sync.nonfairTryAcquire(1);

}

从上面的方法可以看出加锁的操作都是交给Sync类来实现的,下面就来看看Sync类

构造方法

/**

* Creates an instance of {@code ReentrantLock}.

* This is equivalent to using {@code ReentrantLock(false)}.

public ReentrantLock() {

sync = new NonfairSync();

}

/**

* Creates an instance of {@code ReentrantLock} with the

* given fairness policy.

* @param fair {@code true} if this lock should use a fair ordering policy

public ReentrantLock(boolean fair) {

sync = fair ? new FairSync() : new NonfairSync();

}

两种构造方法其实是对应这两种锁, 公平锁和非公平锁, 公平锁是依赖FairSync 类来实现的, 非公平锁是依赖NonfairSync来实现的

NonfairSync类详解, 非公平获取锁的真正操作类

静态内部final类

/**

* Sync object for non-fair locks

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);

}

NonfairSync类实现了虚拟类Sync 的lock 和tryAcquire 方法

而Sync 又继承了AbstractQueuedSynchronizer 虚拟类, AbstractQueuedSynchronizer 是一个很重要的类内部维护了等待获取锁的线程队列

lock方法

加锁方法, 方法内有两个分支逻辑,

先判断是否是无锁状态并尝试加锁compareAndSetState , 如果无锁且加锁成功则把当前线程加入AQS队列中setExclusiveOwnerThread.

尝试获取锁没有成功, 就调用acquire 方法来获取锁

compareAndSetState方法判断

protected final boolean compareAndSetState(int expect, int update) {

// See below for intrinsics setup to support this

return unsafe.compareAndSwapInt(this, stateOffset, expect, update);

}

内部使用unsafe.compareAndSwapInt方法, 这方法是native方法. 是把比较和设置两步作为原子操作的方法.

setExclusiveOwnerThread方法

这个方法就是 AbstractQueuedSynchronizer 类的方法, 左右就是把当前线程标记成获取锁的线程

acquire方法, 真正获取锁的方法.

这个是NonfairSync 父类的父类AbstractQueuedSynchronizer 类的方法

public final void acquire(int arg) {

if (!tryAcquire(arg) &&

acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) // 如果获取到锁就会跳出这个循环, 如果获取不到锁, 会一直阻塞在这里

selfInterrupt();

}

内部一个if判断后的调用selfInterrupt方法. 重点在if判断中逻辑.

if中首先调用tryAcquire方法, tryAcquire 在AbstractQueuedSynchronizer 中没有实现逻辑只是抛出异常, 所以具体的逻辑实在子类NonfairSync 中,

NonfairSync.tryAcquire方法

protected final boolean tryAcquire(int acquires) {

return nonfairTryAcquire(acquires);

}

可以看到调用了nonfairTryAcquire 方法, nonfairTryAcquire方法又在Sync类中实现

Sync.nonfairTryAcquire方法如下

final boolean nonfairTryAcquire(int acquires) {

final Thread current = Thread.currentThread(); //获取当前线程

int c = getState(); // 获取当前锁的计数器

if (c == 0) { // 计数器0,说明当前锁是空闲的

if (compareAndSetState(0, acquires)) { //比较并获取锁

setExclusiveOwnerThread(current);

return true;

}

else if (current == getExclusiveOwnerThread()) { // 当前线程就是已经获取锁的线程

int nextc = c + acquires; // 直接计数器上加 acquires, 传入的是1

if (nextc < 0) // 计数器数字异常

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

setState(nextc); // 设置计数器的数值. 这里可以直接设置, 因为当前线程就是已经获取锁的线程, 可重入锁就是体现在这的

return true;

}

return false; // 获取锁失败

}

这个方法的作用, 就是看下锁的状态是否可以直接获取锁, 两种情况可以直接获取锁

锁是空闲状态, 没有线程获取锁

当前线程就是获取锁的线程, 直接计数器加值表示重复获取锁

acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法,

这个也是AbstractQueuedSynchronizer 的方法. 这个方法才是真正的自旋阻塞获取锁的方法

/**

* Acquires in exclusive uninterruptible mode for thread already in

* queue. Used by condition wait methods as well as acquire.

* @param node the node

* @param arg the acquire argument

* @return {@code true} if interrupted while waiting

final boolean acquireQueued(final Node node, int arg) {

boolean failed = true; //自旋是否的标识符

try {

boolean interrupted = false;

for (;;) {

final Node p = node.predecessor(); //获取当前线程的上一个线程

if (p == head && tryAcquire(arg)) { // tryAcquire 就是尝试获取一下锁

setHead(node);

p.next = null; // help GC

failed = false;

return interrupted;

}

if (shouldParkAfterFailedAcquire(p, node) &&

parkAndCheckInterrupt())

interrupted = true;

}

} finally {

if (failed)

cancelAcquire(node);

}

node.predecessor(); 就是获取当前线程的上一个线程

如果当前线程获取锁成功, 就把当前线程设置成队列的头部, 并且方法返回false

如果当前线程获取锁失败, 就进入shouldParkAfterFailedAcquire 方法, shouldParkAfterFailedAcquire内部会判断当前线程的上个线程的状态标记, 如果标记是<0(标识有问题) 就把上个线程移除队列, 如果标识是 SIGNAL就返回true, 如果是其他的就设置成SIGNAL 并且返回false. SIGNAL 标识线程阻塞中

parkAndCheckInterrupt方法会判断当前线程是否应该中断,

finally 中的方法在正常获取到锁的时候回运行, cancelAcquire 中把当前线程和前面的线程都移除队列

其中addWaiter(Node.EXCLUSIVE) 方法就是把当前线程封装成Node, 并且把这个Node增加在队列的尾部

private Node addWaiter(Node mode) {

Node node = new Node(Thread.currentThread(), mode);

// Try the fast path of enq; backup to full enq on failure

Node pred = tail;

if (pred != null) {

node.prev = pred;

if (compareAndSetTail(pred, node)) { // 把当前线程比较并设置成线程对列的尾部

pred.next = node;

return node;

}

// 设置失败就走到这里了

enq(node); //这个方法内部进行循环比较并设置成线程队列的尾部. 如果队列还是空的, 就new一个新的Node设置在头部

return node;

}

到这里就是加锁逻辑全部走完

解锁的逻辑

unlock解锁方法

public void unlock() {

sync.release(1);

}

release方法在是在AQS中实现的

public final boolean release(int arg) {

if (tryRelease(arg)) {

Node h = head;

if (h != null && h.waitStatus != 0)

unparkSuccessor(h);

return true;

}

return false;

}

tryRelease 解锁方法

是在Sync中实现的

protected final boolean tryRelease(int releases) {

int c = getState() - releases; //当前锁计数器减去一些

if (Thread.currentThread() != getExclusiveOwnerThread()) //如果当前线程不是获取锁的线程,直接抛出异常

throw new IllegalMonitorStateException();

boolean free = false;

if (c == 0) { //此次释放后, 计数器等于0.

free = true;

setExclusiveOwnerThread(null); // 设置队列中锁线程标记为null

}

setState(c); // 设置新的计数器

return free;

}

释放锁的逻辑很简单

unparkSuccessor方法

在释放锁成功后, 会进行这个方法. 这个方法会把后续的线程唤醒. LockSupport.unpark(s.thread); 就是唤醒线程方法

private void unparkSuccessor(Node node) {

// 将状态设置为同步状态

int ws = node.waitStatus;

if (ws < 0) compareAndSetWaitStatus(node, ws, 0); // 获取当前节点的后继节点，如果满足状态，那么进行唤醒操作 // 如果没有满足状态，从尾部开始找寻符合要求的节点并将其唤醒 Node s = node.next; if (s == null || s.waitStatus > 0) {

s = null;

for (Node t = tail; t != null && t != node; t = t.prev)

if (t.waitStatus <= 0)

s = t;

}

if (s != null)

LockSupport.unpark(s.thread);

}

FairSync公平锁的逻辑

lock方法

加锁逻辑, 与NoFairSync区别是直接

final void lock() {