ReentrantLock源码分析
概述
ReentrantLock是一个可重入的互斥锁,也被称为独占锁。它支持公平锁和非公平锁两种模式。
<!--more-->
ReentrantLock的使用方法
下面看一个最初级的例子:
public class Test { //默认内部采用非公平实现 ReentrantLock lock=new ReentrantLock(); public void myMethor(){ lock.lock(); //需要加锁的一些操作 //一定要确保unlock能被执行到,尤其是在存在异常的情况下 lock.unlock(); } }
在进入方法后,在需要加锁的一些操作执行之前需要调用lock方法,在jdk文档中对lock方法详细解释如下:
获得锁。 如果锁没有被另一个线程占用并且立即返回,则将锁定计数设置为1。 如果当前线程已经保持锁定,则保持计数增加1,该方法立即返回。 如果锁被另一个线程保持,则当前线程将被禁用以进行线程调度,并且在锁定已被获取之前处于休眠状态,此时锁定保持计数被设置为1。
这里也很好的解释了什么是可重入锁,如果一个线程已经持有了锁,它再次请求获取自己已经拿到的锁,是能够获取成功的,这就是可重入锁。
在需要加锁的代码执行完毕之后,就会调用unlock释放掉锁。在jdk文档之中对,unlock的解释如下:
尝试释放此锁。 如果当前线程是该锁的持有者,则保持计数递减。 如果保持计数现在为零,则锁定被释放。 如果当前线程不是该锁的持有者,则抛出IllegalMonitorStateException 。
在这里有一个需要注意的地点,lock和unlock都反复提到了一个计数,这主要是因为ReentrantLock是可重入的。每次获取锁(重入)就将计数器加一,每次释放的时候的计数器减一,直到计数器为0,就将锁释放掉了。
以上就是最基础,最简单的使用方法。其余的一些方法,都是一些拓展的功能,查看jdk文档即可知道如何使用。
源码分析
继承体系
可以看出ReentrantLock继承自AQS并实现了Lock接口。它内部有公平锁和非公平锁两种实现,这两种实现都是继承自Sync。根据ReentrantLock决定到底采用公平锁还是非公平锁实现。
public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync(); }
核心方法源码分析
Lock方法
- 首先调用具体的Lock实现.sync可能是非公平锁实现也可能是公平锁实现,这取决于你new对象时的参数。
public void lock() { sync.lock(); }
我们以非公平锁实现来看下面的下面的代码。
- 非公平锁的lock方法的具体实现如下
final void lock() { if (compareAndSetState(0, 1)) setExclusiveOwnerThread(Thread.currentThread()); else acquire(1); }
首先进来就是一个判断,其中判断的条件就是compareAndSetState(0, 1)
.毫无疑问这是一个CAS。它的意思时如果当前的state的值的为0就将1与其交换(可以理解为将1赋值给0)并返回true。其实在这一步如果state的值修改成功了,那么锁就获取成功了。setExclusiveOwnerThread(Thread.currentThread())
这行代码就是将当前线程设置为该排他锁的拥有者。
如果CAS失败了,那么就调用acquire(1);
- 如果初次获得锁失败就调用
qcquire(1)
这个方法的具体实现如下;
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
这个方法进来首先第一步就是调用tryAcquire(arg)
. 那么该方法是干什么的呢? 非公平锁实际是调用了这个实现:
protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); }
它具体的实现是在nonfairTryAcquire(acquires)
中。
final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); //获取锁的状态state,这就是前面我们CAS的操作对象 if (c == 0) { //c==0说明没被其它获取 if (compareAndSetState(0, acquires)) { //CAS修改state //CAS修改成功,说明获取锁成功,将当前线程设置为该排他锁的拥有者 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; }
- 第二次尝试获取锁失败后,就进行下一步操作 我们再会过头看
void acquire(int arg)
首先尝试获取锁,获取成功就直接返回了,获取失败就会执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
进行排队。 这一行代码可以分为两部分看,一部分是addWaiter(Node.EXCLUSIVE)
一部分是acquireQueued
.我们先看addWaiter(Node.EXCLUSIVE)
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); return node; }
初始化对立对入队的具体实现如下:
private Node enq(final Node node) { for (;;) { Node t = tail; if (t == null) { // Must initialize //初始化队列 if (compareAndSetHead(new Node())) tail = head; } else { //队列初始化成功,进行入队 node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }
这里稍微补充一下这个AQS中的这个等待队列。
- 节点也创建了,等待队列也入了 现在该看
boolean acquireQueued(final Node node, int arg)
方法了。 这个方法的具体实现如下:
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(arg)再次尝试获取锁 setHead(node); p.next = null; // help GC failed = false; return interrupted; } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) //根据情况进入park状态 interrupted = true; } } finally { if (failed) cancelAcquire(node); } }
unlock方法
- 和加锁类似,调用具体的实现
public void unlock() { sync.release(1); }
- 具体的release实现
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(arg)
方法,这个方法就是实现释放资源的关键。释放的具体操作,也印证了在jdk文档之中的关于unlock和lock的说明。
protected final boolean tryRelease(int releases) { int c = getState() - releases; //计算释放后的state的值 if (Thread.currentThread() != getExclusiveOwnerThread()) //如果当前线程没有持有锁,就抛异常 throw new IllegalMonitorStateException(); boolean free = false; //标记为释放失败 if (c == 0) { //如果state为0了,说没没有线程占有该锁了 //进行重置所有者 free = true; setExclusiveOwnerThread(null); } //重置state的值 setState(c); return free; }
- 如果还有线程在等待锁资源,那么就可以唤醒它们了 回到
boolean release(int arg)
看
if (h != null && h.waitStatus != 0) //唤醒等待的线程,可以拿锁了 unparkSuccessor(h);
ReentrantLock的高阶使用方法
我们使用synchronized的时候,可以通过wait和notify来让线程等待,和唤醒线程。在ReentrantLock中,我们也可以使用Condition中的await和signal来使线程等待和唤醒。 以下面这段代码来解释:
public class Test { static ReentrantLock lock=new ReentrantLock(); //获取到condition static Condition condition=lock.newCondition(); public static class TaskA implements Runnable{ @Override public void run() { lock.lock(); System.out.println(Thread.currentThread().getName() + "开始执行"); try { System.out.println(Thread.currentThread().getName() + "准备释放掉锁并等待"); //在此等待,直到其它线程唤醒 condition.await(); System.out.println(Thread.currentThread().getName() + "重新拿到锁并执行"); } catch (InterruptedException e) { e.printStackTrace(); }finally { lock.unlock(); } } } public static class TaskB implements Runnable{ @Override public void run() { lock.lock(); System.out.println(Thread.currentThread().getName() + "开始执行"); System.out.println(Thread.currentThread().getName() + "开始唤醒等待的线程"); //唤醒等待的线程 condition.signal(); try { Thread.sleep(2000); System.out.println(Thread.currentThread().getName() + "任务执行完毕"); }catch (InterruptedException e){ e.printStackTrace(); }finally { lock.unlock(); } } } public static void main(String[] args) { Thread taskA=new Thread(new TaskA(),"taskA"); Thread taskB=new Thread(new TaskB(),"taskB"); taskA.start(); taskB.start(); } }
输出结果:
taskA开始执行 taskA准备释放掉锁并等待 taskB开始执行 taskB开始唤醒等待的线程 taskB任务执行完毕 taskA重新拿到锁并执行
现象解释: 首先taskA拿到锁,并执行,到condition.await();
释放锁,并进入阻塞。taskB因此拿到刚才taskA释放掉的锁,taskB开始执行。taskB执行到condition.signal();
唤醒了taskA,taskB继续执行,taskA因为拿不到锁,因此虽然已经被唤醒了,但是还是要等到taskB执行完毕,释放锁后,才有机会拿到锁,执行自己的代码。
那么这个过程,源码到底是如何实现的呢?
Condition源码分析
await()的源码分析
具体的实现如下:
public final void await() throws InterruptedException { if (Thread.interrupted()) throw new InterruptedException(); Node node = addConditionWaiter(); //添加一个条件节点 int savedState = fullyRelease(node); //释放掉所有的资源 int interruptMode = 0; while (!isOnSyncQueue(node)) { //如果当前线程不在等待队列中,park阻塞 LockSupport.park(this); if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) break; //线程被中断就跳出循环 } if (acquireQueued(node, savedState) && interruptMode != THROW_IE) interruptMode = REINTERRUPT; if (node.nextWaiter != null) // clean up if cancelled //取消条件队列中已经取消的等待节点的链接 unlinkCancelledWaiters(); if (interruptMode != 0) //等待结束后处理中断 reportInterruptAfterWait(interruptMode); }
基本的步骤如下:
- 首先判断线程是否被中断,如果中断则抛出
InterruptedException()
异常 - 添加当前线程到条件队列中去,然后释放掉所有的资源
- 如果当前线程不在等待队列中,就直接park阻塞当前线程
signal()方法源码分析
具体的实现代码如下:
public final void signal() { if (!isHeldExclusively()) throw new IllegalMonitorStateException(); Node first = firstWaiter; if (first != null) doSignal(first); }
这个方法中最重要的也就是doSignal(first)
. 它的实现如下:
private void doSignal(Node first) { do { if ( (firstWaiter = first.nextWaiter) == null) lastWaiter = null; first.nextWaiter = null; //解除等待队列中首节点的链接 } while (!transferForSignal(first) && //转移入等待队列 (first = firstWaiter) != null); }
该方法所做的事情就是从等待队列中移除指定节点,并将其加入等待队列中去。 转移节点的方法实现如下:
final boolean transferForSignal(Node node) { /* * If cannot change waitStatus, the node has been cancelled. */ if (!compareAndSetWaitStatus(node, Node.CONDITION, 0)) //CAS修改状态失败,说明节点被取消了,直接返回false return false; /* * Splice onto queue and try to set waitStatus of predecessor to * indicate that thread is (probably) waiting. If cancelled or * attempt to set waitStatus fails, wake up to resync (in which * case the waitStatus can be transiently and harmlessly wrong). */ Node p = enq(node); //加入节点到等待队列 int ws = p.waitStatus; if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) //如果前节点被取消,说明当前为最后一个等待线程,直接unpark唤醒, LockSupport.unpark(node.thread); return true; }
至此ReentrantLock的源码分析就结束了!
原文出处:https://www.cnblogs.com/zofun/p/12215848.html
- ReentrantLock 源码分析
- ReentrantLock之公平锁源码分析
- 【JUC】JDK1.8源码分析之ReentrantLock(三)
- jdk 源码分析(9)java ReentrantReadWriteLock分析
- Java显式锁学习总结之四:ReentrantLock源码分析
- Java显式锁学习总结之四:ReentrantLock源码分析
- ReentrantReadWriteLock实现分析(源码)
- 【JUC】JDK1.8源码分析之ReentrantLock
- Java多线程之ReentrantLock实现原理和源码分析(二)
- JUC - ReentrantReadWriteLock 源码分析
- Java并发编程 ReentrantLock 源码分析
- Java并发系列之ReentrantLock源码分析
- ReentrantReadWriteLock 源码分析
- ReentrantLock源码分析(二)
- JUC--ReentrantLock及Condition源码分析
- ReentrantLock源码分析(一)
- Java显式锁学习总结之四:ReentrantLock源码分析
- ReentrantLock 源码分析从入门到入土
- JUC - ReentrantLock 源码分析
- ReentrantLock之非公平锁源码分析