前言
当我们遇到应用层面的性能瓶颈时, 第一想法就是是否可拆分成多个任务, 使用多线程来并行处理. 而伴随着多线程而来的安全问题, 我们可以使用synchronized关键字或者Lock实现类来解决.
两种锁的用法都不复杂, 但却一直不了解它们的实现原理. synchronized关键字是JVM底层实现的, 不好探究, 于是开始探究Lock的实现类ReentrantLock.
话不多说, 我们直接看ReentrantLock源码
public class ReentrantLock implements Lock{
private final Sync sync;
public ReentrantLock() {
sync = new NonfairSync();
}
public void lock() {
sync.lock();
}
public void unlock() {
sync.release(1);
}
/* 省略若干 */
}
可以看到ReentrantLock的核心方法都是由成员变量sync实现的, 我们先看NonfairSync.lock()
class NonfairSync extends Sync {
final void lock() {
// CAS获取锁
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
// unsafe操作类
private static final Unsafe unsafe = Unsafe.getUnsafe();
// 锁持有线程
private transient Thread exclusiveOwnerThread;
/**
* CAS获取锁
*/
protected final boolean compareAndSetState(int expect, int update) {
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
/* 为了看起来方便, 已把部分父类方法放在了这里 */
}
NonfairSync.lock()直接调用了compareAndSetState方法, 如果成功, 就代表获取到了锁, 然后把锁的持有线程设置为当前线程. 如果失败, 就调用acquire(1)
在这里, 得补充一下CAS的概念
CAS
全称: CompareAndSwap. 顾名思义, 就是比较然后交换. CAS的原理类似数据库的乐观锁, 假设现在乐观锁version=0, 然后更新的时候我们set version = 1 where version = 0, 这个更新是一个原子操作, 即使多个线程同时来修改, 也只有一个线程会修改成功.
在Java中, 通过Unsafe类的native方法来实现CAS.
回到NonfairSync.lock(), 调用compareAndSetState(0, 1)的意思是: 如果锁对象的标记是0, 那么就设置成1. (锁标记: 0代表锁是空的, 1或以上代表锁已被占用)
如果获取锁成功, 程序便往下走了, 假如获取锁失败, 则会调用acquire(1)
public final void acquire(int arg) {
// 尝试获取锁
if (!tryAcquire(arg) &&
// 排队获取锁
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
/**
* 尝试获取锁
*/
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
// 锁标记
private volatile int 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;
}
/* 为了看起来方便, 已把部分父类方法放在了这里 */
可以看到, 程序获取了锁标记state, 然后判断如果等于0, 那么直接CAS获取锁, 如果不等于0, 再判断当前线程和锁持有线程是否一致, 如果一致, 把锁标记+1, 返回true(获取锁成功)
我们继续看获取锁失败会发生什么
public final void acquire(int arg) {
// tryAcquire(arg)失败则调用 acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
/**
* 添加等待节点
*/
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
if (pred != null) {
node.prev = pred;
// CAS设置新节点到链表尾巴
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 循环+CAS设置新节点到链表尾巴
enq(node);
return node;
}
/**
* 排队获取锁
*/
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)) {
// 获取锁成功, 把当前节点设置到链表头部
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 获取锁失败的最终处理, 把当前线程设置成Blocked状态
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
首先, 程序创建了一个等待节点, 然后把节点添加到等待链表的最后一位, 添加过程中使用了循环+CAS, CAS如果失败, 就自旋直到成功
然后, 我们主要看acquireQueued方法, 程序首先判断了当前等待节点的前一位是否为等待链表头部, 如果是头部, 就去CAS获取锁
如果前一位非头部或者获取锁失败, 就会调用shouldParkAfterFailedAcquire()判断是否应该把当前线程设置为阻塞状态, 然后调用parkAndCheckInterrupt()来把当前线程阻塞, 直到被唤醒.
ReentrantLock.lock()到此基本结束, 下面我们再看看unlock()
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;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
unlock()比较简单, 可以看出程序只需要判断锁持有线程和当前线程是否一致, 如果不一致, 直接抛出IllegalMonitorStateException, 因为你都没拿到锁, 你释放个什么鬼啊, 同学们应该对这个异常比较亲切.
如果一致, 就把锁标记-1, 如果标记等于0了, 代表锁已经完全释放了, 那么就把锁持有线程设置为空.
这里补充个概念: 可重入锁
可重入锁是指: 获取到某锁的线程, 可以再次获取该锁, 然后使锁标记+1, 当线程把所有的标记释放时, 别的线程才能获取该锁, 可重入锁能有效减少死锁和提高性能, synchronized关键字本身也是一个可重入锁
释放锁以后, 查看一下锁的等待链表是否为空, 如果不为空, 就通知一下头部节点, 别睡了, 起来工作吧
