深入理解Java中的锁(二)
locks包结构层次
Lock 接口
方法签名 | 描述 |
---|---|
void lock(); | 获取锁(不死不休) |
boolean tryLock(); | 获取锁(浅尝辄止) |
boolean tryLock(long time, TimeUnit unit) throws InterruptedException; | 获取锁(过时不候) |
void lockInterruptibly() throws InterruptedException; | 获取锁(任人摆布) |
void unlock(); | 释放锁 |
Condition newCondition(); |
代码示例:
public class GetLockDemo {
// 公平锁
// static Lock lock =new ReentrantLock(true);
// 非公平锁
static Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
// 主线程 拿到锁
lock.lock();
Thread thread =
new Thread(
() -> {
// 子线程 获取锁(不死不休)
System.out.println("begain to get lock...");
lock.lock();
System.out.println("succeed to get lock...");
// // 子线程 获取锁(浅尝辄止)
// boolean result = lock.tryLock();
// System.out.println("是否获得到锁:" + result);
//
// // 子线程 获取锁(过时不候)
// try {
// boolean result1 = lock.tryLock(5, TimeUnit.SECONDS);
// System.out.println("是否获得到锁:" + result1);
// } catch (InterruptedException e) {
// e.printStackTrace();
// }
//
// // 子线程 获取锁(任人摆布)
// try {
// System.out.println("start to get lock Interruptibly");
// lock.lockInterruptibly();
// } catch (InterruptedException e) {
// e.printStackTrace();
// System.out.println("dad asked me to stop...");
// }
});
thread.start();
Thread.sleep(10000L);
lock.unlock();
}
}
结论:
- lock() 最常用
- lockInterruptibly() 方法一般更昂贵,有的实现类可能没有实现 lockInterruptible() 方法。只有真的需要用中断时,才使用,使用前应看清实现类对该方法的描述。
Condition
Object中的wait(), notify(), notifyAll()方法是和synchronized配合使用的可以唤醒一个或者多个线程。Condition是需要与Lock配合使用的,提供多个等待集合和更精确的控制(底层是park/unpark机制);
协作方式 | 死锁方式1 (锁) | 死锁方式2(先唤醒,再挂起) | 备注 |
---|---|---|---|
suspend/resume | 死锁 | 死锁 | 弃用 |
wait/notify | 不死锁 | 死锁 | 只用于synchronized关键字 |
park/unpark | 死锁 | 不死锁 | |
condition | 不死锁 | 死锁 |
condition代码示例:
public class ConditionDemo {
static Lock lock = new ReentrantLock();
static Condition condition = lock.newCondition();
public static void main(String[] args) throws InterruptedException {
Thread thread =
new Thread(
() -> {
lock.lock();
System.out.println("condition.await()");
try {
condition.await();
System.out.println("here i am...");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
});
thread.start();
Thread.sleep(2000L);
lock.lock();
condition.signalAll();
lock.unlock();
}
}
ReetrantLock
ReentrantLock是可重入锁,同一线程可以多次获取到锁
ReentrantLock实现原理分析
- ReentrantLock需要一个owner用来标记那个线程获取到了锁,一个count用来记录加锁的次数和一个waiters等待队列用来存放没有抢到锁的线程列表
- 当有线程进来时,会先判断count的值,如果count为0说明锁没有被占用
- 然后通过CAS操作进行抢锁
- 如果抢到锁则count的值会加1,同时将owner设置为当前线程的引用
- 如果count不为0同时owner指向当前线程的引用,则将count的值加1
- 如果count不为0同时owner指向的不是当前线程的引用,则将线程放入等待队列waiters中
- 如果CAS抢锁失败,则将线程放入等待队列waiters中
- 当线程使用完锁后,会释放其持有的锁,释放锁时会将count的值减1,如果count值为0则将owner设为null
- 如果count值不为0则会唤醒等待队列头部的线程进行抢锁
手动实现ReentrantLock代码示例:
public class MyReentrantLock implements Lock {
// 标记重入次数的count值
private AtomicInteger count = new AtomicInteger(0);
// 锁的拥有者
private AtomicReference<Thread> owner = new AtomicReference<>();
// 等待队列
private LinkedBlockingDeque<Thread> waiters = new LinkedBlockingDeque<>();
@Override
public boolean tryLock() {
// 判断count是否为0,若count!=0,说明锁被占用
int ct = count.get();
if (ct != 0) {
// 判断锁是否被当前线程占用,若被当前线程占用,做重入操作,count+=1
if (owner.get() == Thread.currentThread()) {
count.set(ct + 1);
return true;
} else {
// 若不是当前线程占用,互斥,抢锁失败,return false
return false;
}
} else {
// 若count=0, 说明锁未被占用,通过CAS(0,1) 来抢锁
if (count.compareAndSet(ct, ct + 1)) {
// 若抢锁成功,设置owner为当前线程的引用
owner.set(Thread.currentThread());
return true;
} else {
return false;
}
}
}
@Override
public void lock() {
// 尝试抢锁
if (!tryLock()) {
// 如果失败,进入等待队列
waiters.offer(Thread.currentThread());
// 自旋
for (; ; ) {
// 判断是否是队列头部,如果是
Thread head = waiters.peek();
if (head == Thread.currentThread()) {
// 再次尝试抢锁
if (!tryLock()) {
// 若抢锁失败,挂起线程,继续等待
LockSupport.park();
} else {
// 若成功,就出队列
waiters.poll();
return;
}
} else {
// 如果不是队列头部,就挂起线程
LockSupport.park();
}
}
}
}
public boolean tryUnlock() {
// 判断,是否是当前线程占有锁,若不是,抛异常
if (owner.get() != Thread.currentThread()) {
throw new IllegalMonitorStateException();
} else {
// 如果是,就将count-1 若count变为0 ,则解锁成功
int ct = count.get();
int nextc = ct - 1;
count.set(nextc);
// 判断count值是否为0
if (nextc == 0) {
owner.compareAndSet(Thread.currentThread(), null);
return true;
} else {
return false;
}
}
}
@Override
public void unlock() {
// 尝试释放锁
if (tryUnlock()) {
// 获取队列头部, 如果不为null则将其唤醒
Thread thread = waiters.peek();
if (thread != null) {
LockSupport.unpark(thread);
}
}
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public void lockInterruptibly() throws InterruptedException {}
@Override
public Condition newCondition() {
return null;
}
}
synchronized VS Lock
synchronized:
优点:
- 使用简单,语义清晰,哪里需要点哪里
- 由JVM提供,提供了多种优化方案(锁粗化,锁消除,偏向锁,轻量级锁)
- 锁的释放由虚拟机完成,不用人工干预,降低了死锁的可能性
缺点:悲观的排他锁,无法实现锁的高级功能如公平锁,读写锁等
Lock:
优点:可以实现synchronized无法实现的锁的高级功能如公平锁,读写锁等,同时还可以实现更多的功能
缺点:需手动释放锁unlock,使用不当容易造成死锁
结论: 两者都是可重入锁,synchronized可以类比为傻瓜相机,提供了固定的功能,而Lock可以类比为单方,可以根据需要调节所需的功能
深入理解Java中的锁(二)的更多相关文章
- 深入理解Java中的锁
转载:https://www.jianshu.com/p/2eb5ad8da4dc Java中的锁 常见的锁有synchronized.volatile.偏向锁.轻量级锁.重量级锁 1.synchro ...
- 深入理解Java中的锁(一)
Java中锁的概念 自旋锁 : 是指当一个线程在获取锁的时候,如果锁已经被其他线程获取,那么该线程将循环等待,然后不断判断锁是否能够被成功获取,直到获取到锁才会退出循环. 乐观锁 : 假定没有冲突,在 ...
- 深入理解Java中的锁(三)
ReadWriteLock接口 读写锁维护一对关联锁,一个只用于读操作,一个只用于写操作.读锁可以由多个线程同时持有,又称共享锁.写锁同一时间只能由一个线程持有,又称互斥锁.同一时间,两把锁不能被不同 ...
- java 中的锁 -- 偏向锁、轻量级锁、自旋锁、重量级锁(转载)
之前做过一个测试,详情见这篇文章<多线程 +1操作的几种实现方式,及效率对比>,当时对这个测试结果很疑惑,反复执行过多次,发现结果是一样的: 1. 单线程下synchronized效率最高 ...
- java 中的锁 -- 偏向锁、轻量级锁、自旋锁、重量级锁
之前做过一个测试,详情见这篇文章<多线程 +1操作的几种实现方式,及效率对比>,当时对这个测试结果很疑惑,反复执行过多次,发现结果是一样的: 1. 单线程下synchronized效率最高 ...
- Java并发编程:Java中的锁和线程同步机制
锁的基础知识 锁的类型 锁从宏观上分类,只分为两种:悲观锁与乐观锁. 乐观锁 乐观锁是一种乐观思想,即认为读多写少,遇到并发写的可能性低,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新 ...
- 深入理解Java中的不可变对象
深入理解Java中的不可变对象 不可变对象想必大部分朋友都不陌生,大家在平时写代码的过程中100%会使用到不可变对象,比如最常见的String对象.包装器对象等,那么到底为何Java语言要这么设计,真 ...
- Java并发指南4:Java中的锁 Lock和synchronized
Java中的锁机制及Lock类 锁的释放-获取建立的happens before 关系 锁是java并发编程中最重要的同步机制.锁除了让临界区互斥执行外,还可以让释放锁的线程向获取同一个锁的线程发送消 ...
- 扯扯Java中的锁
前言 又过去了一个周末,最近陆陆续续的看了<并发编程的艺术>一书,对锁有不少感悟,这次就聊聊Java中的锁事.本文纯粹是漫谈,想到哪说到哪,但准确性肯定会保证,倘若有不正确之处,还请交流指 ...
随机推荐
- Google地图下载工具代码
// // Google Map Tiles Downloader in C# by coolypf // No rights reserved, neither warranty nor guara ...
- 【Linux】Linux下设备网卡以及硬件管理等
这是Linux下网络硬件管理的基础知识,虽然平时用到的可能比软件的少一点,但是作为基础命令,还是需要记住,以免用时又得查询. 本文参考官方文档:https://wiki.ubuntu.com.cn/% ...
- asp.net mvc实现微信外H5支付方法
一.微信支付方式介绍 微信提供了各种支付方式,试用于各种不同的支付场景,主要有如下几种: 1.刷卡支付 刷卡支付是用户展示微信钱包内的“刷卡条码/二维码”给商户系统扫描后直接完成支付的模式.主要应用线 ...
- Linux使用daemontools
功能: 在使用memcached时候,怕因为一些不可预知的因素导致memcached进程死掉,而又不能及时的发现重启,可以通过daemontools来管理memcached的启动,当memcached ...
- Spring cloud stream【消息分区】
在上篇文章中我们给大家介绍了Stream的消息分组,可以实现消息的重复消费的问题,但在某些场景下分组还不能满足我们的需求,比如,同时有多条同一个用户的数据,发送过来,我们需要根据用户统计,但是消息 ...
- vue结合Ant Design实现后台系统的权限分配(支持无限子级嵌套)
最近公司的业务需要,要做一个后台管理系统的管理系统类似于这样子 功能需求如下: 左边是权限菜单,右边对应的是具体权限. 1.父级权限菜单选中,父级权限菜单的权限包括其中所有子级权限菜单的权限也要选中, ...
- vue项目接入api接口
我们在做项目时,一切基础在于数据上面,所以接入api接口是关键. 访问接口是我们会遇到跨域,而,vue-cli给我们提供了反向代理,所以我们只需要配置一下就可以了. 在config文件中找到index ...
- Spark学习之路(十)—— Spark SQL 外部数据源
一.简介 1.1 多数据源支持 Spark支持以下六个核心数据源,同时Spark社区还提供了多达上百种数据源的读取方式,能够满足绝大部分使用场景. CSV JSON Parquet ORC JDBC/ ...
- 【设计模式】行为型07备忘录模式(Memento Pattern)
参考地址:http://www.runoob.com/design-pattern/memento-pattern.html 对原文总结调整,以及修改代码以更清晰的展示: 备忘录模式(快照模式): ...
- Map集合的4种遍历方式
import java.util.HashMap;import java.util.Iterator;import java.util.Map; public class TestMap { p ...