java lock unlock_详解Java中的ReentrantLock锁
ReentrantLock锁
ReentrantLock是Java中常用的锁,属于乐观锁类型,多线程并发情况下。能保证共享数据安全性,线程间有序性
ReentrantLock通过原子操作和阻塞实现锁原理,一般使用lock获取锁,unlock释放锁,
下面说一下锁的基本使用和底层基本实现原理,lock和unlock底层
lock的时候可能被其他线程获得所,那么此线程会阻塞自己,关键原理底层用到Unsafe类的API: CAS和park
使用
java.util.concurrent.locks.ReentrantLock类
在多线程环境下使用,创建锁对象,调用lock()获取锁开始处理逻辑,处理完unlock()释放锁。注意使用的时候lock和unlock必须成对出现,不然可能出现死锁或者严重堵塞的情况
unlock
//创建锁对象
ReentrantLock lock = new ReentrantLock();
lock.lock(); //获取锁(锁定)
System.out.println("一段需要上锁的代码")
lock.unlock(); //锁释放
执行完代码后,释放锁,让其他线程去获取,需要注意的是,多个线程使用的锁对象必须是同一个。
什么情况需要上锁,就是在多线程不安全的情况下,多个线程操作同一个对象。
如多个线程同时操作一个队列,offer()添加对象,两个线程同时offer,因为不是原子操作,很可能一个线程添加成功,另一个线程添加失败,延伸到一些业务中是要杜绝的问题。
可以用锁解决问题,我们可以定义一个队列同一时间只能被一个拿到锁的线程操作,即保证offer这种非原子操作完成后,释放锁,再让其他线程拿到锁后,才能offer,保证有序的offer,不会丢失信息。
示例
为了体现锁的作用,这里sleep睡眠0.1秒,增加哪个线程获取锁的随机性
因为线程唤醒后,会开始尝试获取锁,多个线程下竞争一把锁是随机的
package javabasis.threads;
import java.util.concurrent.locks.ReentrantLock;
public class LockTest implements Runnable {
public static ReentrantLock lock = new ReentrantLock();//创建锁对象
private int thold;
public LockTest(int h) {
this.thold = h;
}
public static void main(String[] args) {
for (int i = 10; i < 15; i++) {
new Thread(new LockTest(i),"name-" + i).start();
}
}
@Override
public void run() {
try {
Thread.sleep(100);
lock.lock(); //获取锁
System.out.println("lock threadName:" + Thread.currentThread().getName());
{
System.out.print(" writeStart ");
for (int i = 0; i < 15; i++) {
Thread.sleep(100);
System.out.print(thold+",");
}
System.out.println(" writeEnd");
}
System.out.println("unlock threadName:" + Thread.currentThread().getName() + "\r\n");
lock.unlock(); //锁释放
} catch (InterruptedException e) {
}
}
}
运行main方法输出结果:
lock threadName:name-10
writeStart 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10, writeEnd
unlock threadName:name-10
lock threadName:name-14
writeStart 14,14,14,14,14,14,14,14,14,14,14,14,14,14,14, writeEnd
unlock threadName:name-14
lock threadName:name-13
writeStart 13,13,13,13,13,13,13,13,13,13,13,13,13,13,13, writeEnd
unlock threadName:name-13
lock threadName:name-11
writeStart 11,11,11,11,11,11,11,11,11,11,11,11,11,11,11, writeEnd
unlock threadName:name-11
lock threadName:name-12
writeStart 12,12,12,12,12,12,12,12,12,12,12,12,12,12,12, writeEnd
unlock threadName:name-12
这体现在多线程情况下,锁能做到让线程之间有序运行,
如果没有锁,情况可能是 12,13,13,10,10,10,12,没有锁其他线程可能插队执行System.out.print
将上锁的代码注释后输出结果:
lock threadName:name-11
lock threadName:name-12
writeStart lock threadName:name-10
writeStart lock threadName:name-13
writeStart lock threadName:name-14
writeStart writeStart 14,12,10,11,13,11,12,14,10,13,10,13,14,12,11,10,14,12,11,13,14,11,13,12,10,13,10,12,14,11,11,13,10,12,14,14,10,12,11,13,11,14,13,12,10,14,10,11,13,12,14,12,11,13,10,14,10,11,12,13,12,14,11,13,10,11,10,14,13,12,11, writeEnd
unlock threadName:name-11
13,12, writeEnd
unlock threadName:name-12
writeEnd
unlock threadName:name-13
14, writeEnd
unlock threadName:name-14
10, writeEnd
unlock threadName:name-10
原理
ReentrantLock主要用到unsafe的CAS和park两个功能实现锁(CAS + park )
多个线程同时操作一个数N,使用原子(CAS)操作,原子操作能保证同一时间只能被一个线程修改,而修改数N成功后,返回true,其他线程修改失败,返回false,
这个原子操作可以定义线程是否拿到锁,返回true代表获取锁,返回false代表为没有拿到锁。
拿到锁的线程,自然是继续执行后续逻辑代码,而没有拿到锁的线程,则调用park,将线程(自己)阻塞。
线程阻塞需要其他线程唤醒,ReentrantLock中用到了链表用于存放等待或者阻塞的线程,每次线程阻塞,先将自己的线程信息放入链表尾部,再阻塞自己;之后需要拿到锁的线程,在调用unlock 释放锁时,从链表中获取阻塞线程,调用unpark 唤醒指定线程
Unsafe
sun.misc.Unsafe是关键类,提供大量偏底层的API 包括CAS park
sun.misc.Unsafe 此类在openjdk中可以查看
CAS 原子操作
compare and swapz(CAS)比较并交换,是原子性操作,
原理:当修改一个(内存中的)变量o的值N的时候,首先有个期望值expected,和一个更新值x,先比较N是否等于expected,等于,那么更新内存中的值为x值,否则不更新。
public final native boolean compareAndSwapInt(Object o, long offset,
int expected,
int x);
这里offset据了解,是对象的成员变量在内存中的偏移地址,
即底层一个对象object存放在内存中,读取的地址是0x2110,此对象的一个成员变量state的值也在内存中,但内存地址肯定不是0x2110
java中的CAS使用
java.util.concurrent.locks.AbstractQueuedSynchronizer 类
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long stateOffset;
static {
try {
stateOffset = unsafe.objectFieldOffset
(AbstractQueuedSynchronizer.class.getDeclaredField("state")); //获取成员变量state在内存中的偏移量
} catch (Exception ex) { throw new Error(ex); }
}
protected final boolean compareAndSetState(int expect, int update) {
// See below for intrinsics setup to support this
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}
在Java中,compareAndSetState这个操作如果更新成功,返回true,失败返回false,通过这个机制,可以定义锁(乐观锁)。
如三个线程A,B,C,在目标值为0的情况下,同时执行compareAndSetState(0,1) 去修改它
期望值是0,更新值是1,因为是原子操作,在第一个线程操作成功之后目标值变为1,返回true
所以另外两个线程就因为期望值为0不等于1,返回false。
我们可以理解为,返回true的线程拿到了锁。
最终调用的Java类是sun.misc.Unsafe
park 阻塞
Java中可以通过unsafe.park()去阻塞(停止)一个线程,也可以通过unsafe.unpark()让一个阻塞线程恢复继续执行
unsafe.park()
阻塞(停止)当前线程
public native void park(boolean isAbsolute, long time);
根据debug测试,此方法能停止线程自己,最后通过其他线程唤醒
unsafe.unpark()
取消阻塞(唤醒)线程
public native void unpark(Object thread);
根据debug测试,此方法可以唤醒其他被park调用阻塞的线程
park与interrupt的区别
interrupt是Thread类的的API,park是Unsafe类的API,两者是有区别的。
测试了解,Thread.currentThread().interrupt(),线程会继续运行,而Unsafe.park(Thread.currentThread())就是直接阻塞线程,不继续运行代码。
获取锁
线程cas操作失败,可以park阻塞自己,让其他拥有锁的线程在unlock的时候释放自己,达到锁的效果
java.util.concurrent.locks.ReentrantLock的lock方法是
public void lock() {
sync.lock();
}
而sync的实现类其中一个是java.util.concurrent.locks.ReentrantLock.NonfairSync 不公平锁,它的逻辑比较直接
/**
NonfairSync
*/
final void lock() {
if (compareAndSetState(0, 1))//cas操作,如果true 则表示操作成功,获取锁
setExclusiveOwnerThread(Thread.currentThread()); //设置获取锁拥有者为当前线程
else
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);
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
//如果期望值为0,内存值也为0,再次尝试获取锁(此时其他线程也可能尝试获取锁)
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current); //第二次获取成功,放回true
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; //没有获取到锁,返回false,则 !tryAcquire(arg) 为true,执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
}
获取锁失败,线程会进入循环,acquireQueued 方法中for是个无限循环,除非获取锁成功后,才会return。
//获取锁失败后,准备阻塞线程(自己)
//阻塞之前,添加节点存放到链表,其他线程可以通过这个链表唤醒此线程
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)) {//cas操作
pred.next = node;
return node;
}
}
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; //获取锁成功之后才会return跳出此方法
}
if (shouldParkAfterFailedAcquire(p, node) && //如果满足阻塞条件
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);//停止线程(自己)
return Thread.interrupted();
}
释放锁
一个线程拿到锁之后,执行完关键代码,必须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;
}
//java.util.concurrent.locks.ReentrantLock.Sync 的tryRelease
protected final boolean tryRelease(int releases) {
int c = getState() - releases; //这里一般是 1 - 1 = 0
if (Thread.currentThread() != getExclusiveOwnerThread()) //只能是锁的拥有者释放锁
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c); //设置state为0,相当于释放锁,让其他线程compareAndSetState(0, 1)可能成功
return free;
}
protected final void setState(int newState) {
state = newState; //没有cas操作
}
setState不做cas操作是因为,只有拥有锁的线程才调用unlock,不存才并发混乱问题
其他线程没拿到锁不会设值成功,其他线程在此线程设置state为0之前,compareAndSetState(0, 1)都会失败,拿不到锁,此线程设置state为0之后,其他线程compareAndSetState(0, 1)才有可能成功,返回true从而拿到锁
释放线程
线程在获取锁失败后,有可能阻塞线程(自己),在阻塞之前把阻塞线程信息放入链表的
释放锁之后,线程会尝试通过链表释放其他线程(一个),让一个阻塞线程恢复运行
阻塞线程被取消阻塞后如何拿到锁(ReentrantLock中)
有时候线程被中断后,唤醒继续执行后面的代码,
线程没有拿到锁之后主动阻塞自己的,但所还没拿到,被唤醒之后怎么去尝试重新获取锁呢? 里面有一个for循环
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());//拿到锁
else
acquire(1); //没有拿到锁
}
// 上锁失败,会添加一个节点,节点包含线程信息,将此节点放入队列
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
// 存好节点后,将线程(自己)中断,等其他线程唤醒(自己)
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; //如果拿到锁了,才会return
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt()) //没拿到锁时,主动中断Thread.currentThread()
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
被唤醒后继续执行compareAndSetState(0, 1)返回false没拿到锁,则继续循环或阻塞
compareAndSetState(0, 1) 这个操作是获取锁的关键
以上就是详解Java中的ReentrantLock锁的详细内容,更多关于Java中的ReentrantLock锁的资料请关注脚本之家其它相关文章!
java lock unlock_详解Java中的ReentrantLock锁相关推荐
- java system sleep_详解Java中的sleep()和wait()的区别
详解Java中的sleep()和wait()的区别 对于sleep()方法,我们首先要知道该方法是属于Thread类中的.而wait()方法,则是属于Object类中的. sleep()方法导致了程序 ...
- java ftp ftpclient_详解JAVA中使用FTPClient工具类上传下载
详解JAVA中使用FTPClient工具类上传下载 在Java程序中,经常需要和FTP打交道,比如向FTP服务器上传文件.下载文件.本文简单介绍如何利用jakarta commons中的FTPClie ...
- java list jstl_详解javaweb中jstl如何循环List中的Map数据_java - JAVA
文章来源:嗨学网 敏而好学论坛www.piaodoo.com 欢迎大家相互学习 详解javaweb中jstl如何循环List中的Map数据 第一种方式: 1:后台代码(测试) List> lis ...
- java web ip_详解Java Web如何限制访问的IP的两种方法
前一阵子因为在做项目时碰到了这个功能,现在好好总结一下,至于为什么要限制IP访问,我就不多说了.然后百度了一下,现在主要有两种方式去限制IP访问,第一种是最简单的方便的,第二种是通过过滤器来限制访问. ...
- java 重定向 redirect_详解Java从后台重定向(redirect)到另一个项目的方法
(1)通过ModelAndView跳转 @RequestMapping("alipayforward") public ModelAndView alipayforward(Htt ...
- java中断runnable_详解Java 线程中断
一.前言 大家肯定都使用过 Java 线程开发(Thread / Runnable),启动一个线程的做法通常是: new Thread(new Runnable( @Override public v ...
- java字符编码详解_Java中字符编码格式详解
一.前言 在分析Comparable和Comparator的时候,分析到了String类的compareTo方法,String底层是用char[]数组来存放元素,在比较的时候是比较的两个字符串的字符, ...
- java jsch api_详解Java使用Jsch与sftp服务器实现
在实际项目中常会遇到需要连接服务器获取文件的场景,如账务系统需要通过连接行方的sftp服务器拉取回单文件.本文将主要讨论使用Java中的jsch与sftp服务器实现ssh免密连接. 一.什么是SFTP ...
- java tcp demo_详解Java使用TCP实现数据传输实例
这篇文章主要介绍了Java使用TCP实现数据传输实例详解的相关资料,需要的朋友可以参考下 Java使用TCP实现数据传输实例详解 TCP所提供服务的主要特点: 1.面向连接的传输: 2.端到端的通信: ...
最新文章
- 使用Tape和Vue Test Utils编写快速的Vue单元测试
- Hadoop Pipes编程之C++实现WordCount
- mysql通过字段凝视查找字段名称
- JAVA程序设计----数组基础
- [UWP]做个调皮的BusyIndicator
- MongoDB(二):MongoDB的安装
- jquery click点击事件重复执行多次
- mysql隔离性和线性隔离_MySQL--事务,隔离性和隔离级别
- C++ printf输出
- 计算机专业的八字,生辰八字自动计算器软件 生辰八字在线计算器
- Vulnhub DC-7
- while循环是否加分号
- python数据分析师面试题选
- oeasy教您玩转linux-010110内容回顾
- 百度招聘实习生:网页搜索部_语法研究实习工程师(七种语
- Win11电脑速度慢、延迟高怎么办?
- python查看某个函数方法具体有哪些参数怎么做
- 企业大楼AI无感考勤解决方案
- 五类千万不要吃的动物部位
- Linux/Unix 设计思想概述
热门文章
- 计算机基础ABCDEF,计算机应用基础-在线作业abcdef(76页)-原创力文档
- Python 数据处理函数 round()、int()、floor()、ceil()的用法
- 零基础学Python:自定义序列类的详细教程
- python中F/f表达式优于format()表达式
- Python内置函数filter()和匿名函数lambda解析
- Python:粘包问题
- python3.6 使用pyinstaller 打包web程序的方法
- Python基础教程:用模块化来搭项目
- C语言函数指针(结构体函数指针)
- C语言包含头文件时:#include< > 与 #include ““的区别