本文介绍ReentrantLock加锁解锁过程

在看这个类的代码时，先看类的关系，ReentrantLock，内部有sync类，继承了AbstractQueuedSynchronizer，这个类中封装很多锁的公共方法，比如，获取锁，释放锁，创建队列，入队，阻塞，共享锁的逻辑。

测试代码：

import java.util.concurrent.locks.ReentrantLock;
public class TestLock {public static void main(String[] args) {ReentrantLock lock = new ReentrantLock(false);for (int i = 0; i < 5; i++) {new Thread(()->{lock.lock();try{System.out.println(Thread.currentThread().getName()+"-----开始");}finally {lock.unlock();}},"thread"+i).start();}}}

断点设置方式，断点处右键就出现了

源码介绍

创建非公平锁

// 创建锁ReentrantLock lock = new ReentrantLock(false);
// 创建的是非公平锁NonfairSync
public ReentrantLock(boolean fair) {sync = fair ? new FairSync() : new NonfairSync();}
// 空参构造，默认创建的 是非公平锁，
public ReentrantLock() {sync = new NonfairSync();}//非公平锁效率比公平锁高，因为，有时候不存在入队，阻塞，唤醒等操作，一个新的线程进来竞争锁，有可能一
//下就得到锁，直接运行代码。

lock.lock()分析

// java.util.concurrent.locks.ReentrantLock#lock
public void lock() {sync.lock();}

由于上面创建的非公平锁NonfairSync，调用它的lock（）方法；

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() {
// CAS操作state从0改为1，改成功说明加锁成功进入下面的设置拥有锁的线程if (compareAndSetState(0, 1))
// 设置排他线程，锁的拥有线程setExclusiveOwnerThread(Thread.currentThread());else
// 如果state值不是0，尝试获取锁，包含可重入锁acquire(1);}protected final boolean tryAcquire(int acquires) {return nonfairTryAcquire(acquires);}}

如果是第一个线程进来，在if成功后就返回了，获取了锁，后面的线程进来都会进入else，下面看acquire(1);方法

//java.util.concurrent.locks.AbstractQueuedSynchronizer#acquire
public final void acquire(int arg) {
// 尝试获取锁，这个节点，如果上一个线程正好释放锁，这里就能获取成功，跳出if
//获取锁失败，进入下一个判断if (!tryAcquire(arg) &&
//先执行addWaiter(..);方法创建队列，入队，
//再执行外面方法，进入阻塞acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
//设置中断标记，调试时，不进入这个方法，不知道什么情况进入selfInterrupt();}

先看创建队列、入队

//java.util.concurrent.locks.AbstractQueuedSynchronizer#addWaiterprivate Node addWaiter(Node mode) {
//创建一个节点，包含当前线程，mode=nullNode node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;
// tail !=null 说明有队列，这里只需要节点入队，并返回if (pred != null) {node.prev = pred;if (compareAndSetTail(pred, node)) {pred.next = node;return node;}}
//第2线程进来没有获取锁，就进入这个方法，创建队列并入队enq(node);return node;}

再看enq（node）;

//java.util.concurrent.locks.AbstractQueuedSynchronizer#enqprivate Node enq(final Node node) {
//这里是循环，最少会循环2次，直到节点入队成功for (;;) {
//第一次进入循环，tail == nullNode t = tail;if (t == null) { // Must initialize
//创建队列，1创建空节点，2设置为头节点if (compareAndSetHead(new Node()))
// tail也指向这个新创建的节点tail = head;} else {
//第2次循环，进入这，入队node.prev = t;
// CAS操作节点入队尾，if (compareAndSetTail(t, node)) {
//成功入队，建立双向链表结构t.next = node;return t;}}}}

再看acquireQueued(addWaiter(Node.EXCLUSIVE), arg))这个方法

参数中的node就是没有获取锁的第2个线程
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)) {
//下一个节点被唤醒，获取锁成功后修改为head，将节点中的thread和prev置为nullsetHead(node);p.next = null; // help GCfailed = false;return interrupted;}
// shouldParkAfterFailedAcquire（..）会执行2次，第一次设置上一个节点p--waitStatus=-1
//下次进入循环，才会返回trueif (shouldParkAfterFailedAcquire(p, node) &&
// 进入阻塞，返回中断状态parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}}// 这里设置head
private void setHead(Node node) {head = node;node.thread = null;node.prev = null;}

private final boolean parkAndCheckInterrupt() {
// 阻塞，等待被唤醒LockSupport.park(this);
//判断中断状态，并清除中断标记，这里一直返回false，不知道什么时候返回true。return Thread.interrupted();}

如果第一个线程，不释放锁，后面的就都会进入这里阻塞。

阻塞队列

释放锁

调用非公平锁的unlock()方法

public void unlock() {sync.release(1);}

public final boolean release(int arg) {
//尝试释放锁，就是将state-1if (tryRelease(arg)) {
//取出head节点Node h = head;if (h != null && h.waitStatus != 0)
//释放锁unparkSuccessor(h);return true;}return false;}

//node是head节点
private void unparkSuccessor(Node node) {/** If status is negative (i.e., possibly needing signal) try* to clear in anticipation of signalling.  It is OK if this* fails or if status is changed by waiting thread.*/int ws = node.waitStatus;if (ws < 0)
//设置waitStatus=0compareAndSetWaitStatus(node, ws, 0);/** Thread to unpark is held in successor, which is normally* just the next node.  But if cancelled or apparently null,* traverse backwards from tail to find the actual* non-cancelled successor.*/
//取出下一个节点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);}

下一个节点被唤醒之后，会进入

java.util.concurrent.locks.AbstractQueuedSynchronizer#parkAndCheckInterrupt

返回false，在返回上面的调用方法

java.util.concurrent.locks.AbstractQueuedSynchronizer#acquireQueued

进入for (;;)循环，被唤醒的是下一个节点，进入if方法，获取锁成功，设置为head节点。将head节点next值，置为null，等待被gc回收。

可重入：

就是一个线程多次调用lock.lock()方法，state的值就会加1.等释放锁的时候就减1，直到state=0；释放锁成功。

参考文章：写的不错，可以看看

Lock锁-ReentrantLock源码分析_kk阿彬-CSDN博客_reentrantlock源码分析文章目录synchronized的局限性synchronized是java内置的关键字，它提供了一种独占的加锁方式。synchronized的获取和释放锁由jvm实现，用户不需要显示的释放锁，非常方便，然而synchronized也有一定的局限性，例如：当线程尝试获取锁的时候，如果获取不到锁会一直阻塞，这个阻塞的过程，用户无法控制如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待JDK1.5之后发布，加入了Doug Lea实现的java.util.concuhttps://blog.csdn.net/qq_40337086/article/details/110467922

ReentrantLock加锁解锁线程入队源码分析相关推荐

线程池源码分析-FutureTask
1 系列目录线程池接口分析以及FutureTask设计实现线程池源码分析-ThreadPoolExecutor 该系列打算从一个最简单的Executor执行器开始一步一步扩展到ThreadPool ...
Android SQLite多线程读写和线程同步源码分析
没啥诀窍,只需保证几个线程都是用的一个SQLiteDataBase对象就行了. 如果我们非要在不同线程中用两个或更多的SQLiteDataBase对象呢,当然这些SQLiteDataBase对象所操作 ...
Java线程池源码分析
1.个人总结及想法: (1)ThreadPoolExecutor的继承关系? ThreadPoolExecutor继承AbstractExectorService,AbstractExecutorSe ...
吐血整理：Java线程池源码分析(基于JDK1.8建议收藏)
文章目录一.引言二.线程池的参数介绍 1.ThreadPoolExecutor的UML图三.线程池的使用 1.线程池的工作原理 2.线程池类型 2.1.newCachedThreadPool使用 ...
java 线程池源码_java线程池源码分析
我们在关闭线程池的时候会使用shutdown()和shutdownNow(),那么问题来了: 这两个方法又什么区别呢? 他们背后的原理是什么呢? 线程池中线程超过了coresize后会怎么操作呢? 为 ...
jdk、spring、mybatis、线程的源码分析
基础篇从为什么String=String谈到StringBuilder和StringBuffer Java语法糖1:可变长度参数以及foreach循环原理 Java语法糖2:自动装箱和自动拆箱集合 ...
线程池源码分析之ThreadPoolExecutor
前言今天老吕给大家来分享下ThreadPoolExecutor 线程池的实现逻辑,大家伙认真看,一般人我不告诉他的. 线程池相关类图 JDK中线程池相关的类结构关系图获取不同特性的线程池在Exe ...
线程池之ScheduledThreadPoolExecutor线程池源码分析笔记
1.ScheduledThreadPoolExecutor 整体结构剖析. 1.1类图介绍根据上面类图图可以看到Executor其实是一个工具类,里面提供了好多静态方法,根据用户选择返回不同的线程池 ...
linux 2.6线程创建源码分析
2019独角兽企业重金招聘Python工程师标准>>> 上章讲到线程,现在对线程创建的代码流程分析下.来一步一步揭开她神秘的面纱 linux内核创建线程函数 kernel_threa ...
Zygote pre-fork线程池源码分析
前言在Android Q上,google为了加快应用的启动速度.在zygote fork阶段,采用了线程池的方式,来加快fork的过程. 首先,如果让我们自己做,肯定会选择java的线程池模型,先创 ...

ReentrantLock加锁解锁线程入队源码分析

测试代码：

源码介绍

创建非公平锁

lock.lock()分析

释放锁

ReentrantLock加锁解锁线程入队源码分析相关推荐

最新文章

热门文章