学习JUC源码（2）——自定义同步组件
前言
在之前的博文（学习JUC源码（1）——AQS同步队列（源码分析结合图文理解））中，已经介绍了AQS同步队列的相关原理与概念，这里为了再加深理解ReentranLock等源码，模仿构造同步组件的基本模式，编写不可重复的互斥锁Mutex与指定共享线程数量的共享锁。MySharedLock。
主要参考资料《Java并发编程艺术》（有需要的小伙伴可以找我，我这里只有电子PDF）同时结合ReentranLock、AQS等源码。
一、构造同步组件的模式
丛概念方层面，在中，我们知道锁与同步器的相关概念：
- 同步器是实现锁的关键，在锁的实现中聚合同步器，利用同步器实现锁的语义；
- 锁是面向使用者的，提供锁交互的实现；
- 同步器是面向锁的实现者，简化了锁的实现方式，屏蔽了同步状态管理、线程排队、等待/唤醒等底层操作。
从代码层面，同步器是基于模板模式实现的，可以通过可重写的方法中的随便一个窥探：
/**
* 模板方法：
* protected关键字
* 没有任何实现
* @param arg
* @return
*/
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
也就是需要进行以下几步：
1）继承同步器重写指定方法（idea中extends AQS点击快捷键ctrl+O即可显示）
- tryAcquire(int arg)：独占式获取同步状态；
- tryRelease(int arg)：独占式释放同步状态；
- tryAcquireShared(int arg)：共享式获取同步状态，返回大于0的值表示获取成功，否则失败
- tryReleaseShared(int arg)：共享式释放锁
- isHeldExclusively()：当前线程是否在独占模式下被线程占用，一般该方法表示是否被当前线程占用
2）随后将同步器组合在自定义同步组件的实现中，即定义内部类Syn继承AQS，在Syn中重写AQS方法：
public class Sync extends AbstractQueuedSynchronizer{
@Override
protected boolean tryAcquire(int arg) {
final Thread current = Thread.currentThread();
if (compareAndSetState(0, 1)) {
// 获取成功之后，当前线程是该锁的持有者，不需要再可重入数
setExclusiveOwnerThread(current);
return true;
}
return false;
}
@Override
protected boolean tryRelease(int arg) {
if (getState() == 0) {
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
@Override
protected boolean isHeldExclusively() {
return getState() == 1;
}
// 返回Condition，每个Condition都包含了一个队列
Condition newCondition() {
return new ConditionObject();
}
}
3）最后调用同步器提供的模板方法，即同步组件类实现Lock方法之后，在lock/unlock方法中调用内部类Syn的方法acquire(int arg)等方法
public class Mutex implements Lock {
........
@Override
public void lock() {
sync.acquire(1);
}
@Override
public void unlock() {
sync.release(1);
}
........
}
具体请看下面的实践部分
二、互斥不可重入锁
在我之前写过的博文中（详解Java锁的升级与对比（1）——锁的分类与细节（结合部分源码））介绍可重入锁与不可重入锁的区别时，就写到JUC中没有不可重入锁的具体实现，但是可以类比，现在呢，我们可以做到实现了，具体看下面代码，模式完全符合依赖Lock与AQS构造同步组件模式。
（1）Mutex代码实现（核心关键实现已经在代码中注释）
public class Mutex implements Lock {
private final Sync sync = new Sync();
public class Sync extends AbstractQueuedSynchronizer{
@Override
protected boolean tryAcquire(int arg) {
final Thread current = Thread.currentThread();
if (compareAndSetState(0, 1)) {
// 获取成功之后，当前线程是该锁的持有者，不需要再可重入数
setExclusiveOwnerThread(current);
return true;
}
return false;
}
@Override
protected boolean tryRelease(int arg) {
if (getState() == 0) {
throw new IllegalMonitorStateException();
}
setExclusiveOwnerThread(null);
setState(0);
return true;
}
@Override
protected boolean isHeldExclusively() {
return getState() == 1;
}
// 返回Condition，每个Condition都包含了一个队列
Condition newCondition() {
return new ConditionObject();
}
}
@Override
public void lock() {
sync.acquire(1);
}
@Override
public void unlock() {
sync.release(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public Condition newCondition() {
return null;
}
}
其中核心代码就是重写的两个方法：
- tryAcquire(int arg)方法：主要是设置同独占式更新同步状态，CAS实现state+1
- tryRelease(int arg)方法：独占式释放同步状态，释放锁持有
（2）测试Demo
public class MutexDemo {
@Test
public void test(){
final Mutex lock = new Mutex();
class Worker extends Thread {
@Override
public void run() {
// 一直不停在获取锁
while (true) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() +" hold lock, "+new Date());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println(Thread.currentThread().getName() +" release lock, "+new Date());
}
}
}
}
for (int i = 0; i < 10; i++) {
Worker worker = new Worker();
// 以守护进程运行，VM退出不影响运行，这里只是为了一个打印效果，去掉注释一直打印
worker.setDaemon(true);
worker.start();
}
// 每隔一秒换行
for (int j = 0; j < 10; j++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println();
}
}
}
（3）运行结果
Thread-0 hold lock, Tue Dec 08 16:26:42 CST 2020 Thread-0 release lock, Tue Dec 08 16:26:43 CST 2020
Thread-1 hold lock, Tue Dec 08 16:26:43 CST 2020 Thread-2 hold lock, Tue Dec 08 16:26:44 CST 2020
Thread-1 release lock, Tue Dec 08 16:26:44 CST 2020 Thread-3 hold lock, Tue Dec 08 16:26:45 CST 2020
Thread-2 release lock, Tue Dec 08 16:26:45 CST 2020 Thread-3 release lock, Tue Dec 08 16:26:46 CST 2020
Thread-4 hold lock, Tue Dec 08 16:26:46 CST 2020 Thread-4 release lock, Tue Dec 08 16:26:47 CST 2020
Thread-6 hold lock, Tue Dec 08 16:26:47 CST 2020 Thread-7 hold lock, Tue Dec 08 16:26:48 CST 2020
Thread-6 release lock, Tue Dec 08 16:26:48 CST 2020 Thread-7 release lock, Tue Dec 08 16:26:49 CST 2020
Thread-5 hold lock, Tue Dec 08 16:26:49 CST 2020 Thread-8 hold lock, Tue Dec 08 16:26:50 CST 2020
Thread-5 release lock, Tue Dec 08 16:26:50 CST 2020 Thread-8 release lock, Tue Dec 08 16:26:51 CST 2020
Thread-9 hold lock, Tue Dec 08 16:26:51 CST 2020
（4）结果分析
互斥锁的核心就是同一个同步状态只能被一个线程持有，其它线程等待持有线程释放才能竞争获取。截图一开始的运行结果分析：
Thread-0 hold lock, Tue Dec 08 16:26:42 CST 2020 Thread-0 release lock, Tue Dec 08 16:26:43 CST 2020
Thread-1 hold lock, Tue Dec 08 16:26:43 CST 2020 Thread-2 hold lock, Tue Dec 08 16:26:44 CST 2020
Thread-1 release lock, Tue Dec 08 16:26:44 CST 2020
10个线程不断竞争锁，一开始Thread-0在08 16:26:42获取到锁，持有锁1秒后在释放16:26:43时释放，同时Thread-1立马获取到锁，1秒后于16:26:44释放锁，同时Thread-2立马获取到了锁......
根据输出结果来说，完全符合Mutex作为互斥锁这个功能：同一时刻只有一个线程持有锁（同步状态），其它线程等待释放后才能获取。
三、指定共享线程数目的共享锁
（1）代码实现（核心关键实现已经在代码中注释）
public class MyShareLock implements Lock {
// 可以看到共享等待队列中的线程
public Collection<Thread> getSharedQueuedThreads(){
return syn.getSharedQueuedThreads();
}
private final Syn syn = new Syn(2);
private static final class Syn extends AbstractQueuedSynchronizer{
int newShareCount=0;
Syn(int shareCount){
if (shareCount <= 0) {
throw new IllegalArgumentException("share count must large than zero");
}
// 设置初始共享同步状态
setState(shareCount);
}
/**
* 共享锁指定数目
* @param reduceShareCount
* @return
*/
@Override
protected int tryAcquireShared(int reduceShareCount) {
for (;;){
int currentShareCount = getState();
newShareCount = currentShareCount- reduceShareCount;
if (newShareCount < 0 ||
compareAndSetState(currentShareCount,newShareCount)) {
// newShareCount大于等于０才说明获取锁成功
if (newShareCount >= 0) {
// System.out.println(Thread.currentThread().getName()+" hold lock, current share count is "+newShareCount+", "+new Date());
}
// newShareCount小于0表示获取失败所以需要返回
// compareAndSetState(currentShareCount,newShareCount)为true自然表示成功需要返回
return newShareCount;
}
}
}
@Override
protected boolean tryReleaseShared(int returnShareCount) {
for (;;){
int currentShareCount = getState();
newShareCount = currentShareCount + returnShareCount;
if (compareAndSetState(currentShareCount,newShareCount)) {
// System.out.println(Thread.currentThread().getName() +" release lock, current share count is "+newShareCount+", "+new Date());
return true;
}
}
}
protected int getShareCount(){
return getState();
}
}
/**
* 调用内部同步器Syn的acquireShare方法
*/
@Override
public void lock() {
syn.acquireShared(1);
}
/**
* 调用内部同步器Syn的releaseShared方法
*/
@Override
public void unlock() {
syn.releaseShared(1);
}
@Override
public void lockInterruptibly() throws InterruptedException {
if (Thread.interrupted()) {
throw new IllegalStateException();
}
syn.acquireInterruptibly(1);
}
@Override
public boolean tryLock() {
return false;
}
@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return false;
}
@Override
public Condition newCondition() {
return null;
}
}
（2）测试Demo
public class ShareLockTest {
@Test
public void test(){
final MyShareLock lock = new MyShareLock();
class Worker extends Thread {
@Override
public void run() {
// 一直不停在获取锁
while (true) {
lock.lock();
try {
System.out.println(Thread.currentThread().getName() +" hold lock, "+new Date());
// System.out.println(lock.getSharedQueuedThreads());
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
System.out.println(Thread.currentThread().getName() +" release lock, "+new Date());
}
}
}
}
for (int i = 0; i < 10; i++) {
Worker worker = new Worker();
// 以守护进程运行，VM退出不影响运行，这里只是为了一个打印效果，去掉注释一直打印
worker.setDaemon(true);
worker.start();
}
// 每隔一秒换行
for (int j = 0; j < 10; j++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println();
}
}
}
（3）运行结果（结果可能不同）
Thread-1 hold lock, Tue Dec 08 16:36:05 CST 2020
Thread-0 hold lock, Tue Dec 08 16:36:05 CST 2020 Thread-0 release lock, Tue Dec 08 16:36:06 CST 2020
Thread-4 hold lock, Tue Dec 08 16:36:06 CST 2020
Thread-1 release lock, Tue Dec 08 16:36:06 CST 2020
Thread-2 hold lock, Tue Dec 08 16:36:06 CST 2020 Thread-4 release lock, Tue Dec 08 16:36:07 CST 2020
Thread-2 release lock, Tue Dec 08 16:36:07 CST 2020
Thread-5 hold lock, Tue Dec 08 16:36:07 CST 2020
Thread-8 hold lock, Tue Dec 08 16:36:07 CST 2020 Thread-8 release lock, Tue Dec 08 16:36:08 CST 2020
Thread-3 hold lock, Tue Dec 08 16:36:08 CST 2020
Thread-9 hold lock, Tue Dec 08 16:36:08 CST 2020
Thread-5 release lock, Tue Dec 08 16:36:08 CST 2020 Thread-6 hold lock, Tue Dec 08 16:36:09 CST 2020
Thread-7 hold lock, Tue Dec 08 16:36:09 CST 2020
Thread-3 release lock, Tue Dec 08 16:36:09 CST 2020
Thread-9 release lock, Tue Dec 08 16:36:09 CST 2020 Thread-6 release lock, Tue Dec 08 16:36:10 CST 2020
Thread-1 hold lock, Tue Dec 08 16:36:10 CST 2020
Thread-0 hold lock, Tue Dec 08 16:36:10 CST 2020
Thread-7 release lock, Tue Dec 08 16:36:10 CST 2020 Thread-1 release lock, Tue Dec 08 16:36:11 CST 2020
Thread-2 hold lock, Tue Dec 08 16:36:11 CST 2020
Thread-0 release lock, Tue Dec 08 16:36:11 CST 2020
Thread-4 hold lock, Tue Dec 08 16:36:11 CST 2020 Thread-2 release lock, Tue Dec 08 16:36:12 CST 2020
Thread-8 hold lock, Tue Dec 08 16:36:12 CST 2020
Thread-5 hold lock, Tue Dec 08 16:36:12 CST 2020
Thread-4 release lock, Tue Dec 08 16:36:12 CST 2020 Thread-5 release lock, Tue Dec 08 16:36:13 CST 2020
Thread-9 hold lock, Tue Dec 08 16:36:13 CST 2020
Thread-3 hold lock, Tue Dec 08 16:36:13 CST 2020
Thread-8 release lock, Tue Dec 08 16:36:13 CST 2020 Thread-3 release lock, Tue Dec 08 16:36:14 CST 2020
Thread-7 hold lock, Tue Dec 08 16:36:14 CST 2020
Thread-9 release lock, Tue Dec 08 16:36:14 CST 2020
Thread-6 hold lock, Tue Dec 08 16:36:14 CST 2020
（4）结果分析
该指定共享线程数量N的共享锁的最终目的就是多个线程可以持有锁（同步状态），达到共享线程数量N（代码中默认为2）时，其它线程将进入Queue等待获取同步结果，同一时刻只能最多有N个线程持有锁。
同样地，我们分析开头运行结果：
Thread-1 hold lock, Tue Dec 08 16:36:05 CST 2020
Thread-0 hold lock, Tue Dec 08 16:36:05 CST 2020 Thread-0 release lock, Tue Dec 08 16:36:06 CST 2020
Thread-4 hold lock, Tue Dec 08 16:36:06 CST 2020
Thread-1 release lock, Tue Dec 08 16:36:06 CST 2020
Thread-2 hold lock, Tue Dec 08 16:36:06 CST 2020
10个线程不停竞争锁，一开始Thread-0与Thread-1在16:36:05时刻同时获取到了锁，此时已经达到共享数量的最大值，即N，之后持有锁1秒，Thread-0与Thread-1在16:36:06时刻立马释放锁，同时Thread-4与Thread-2立马退出等待队列立马竞争持有锁。
从结果来看，完全是符合ShareLock共享锁功能的：同一时刻最多允许N个线程持有锁，其它线程等待持有线程释放锁！
学习JUC源码（2）——自定义同步组件的更多相关文章
- 学习JUC源码（1）——AQS同步队列（源码分析结合图文理解）
前言 最近结合书籍<Java并发编程艺术>一直在看AQS的源码,发现AQS核心就是:利用内置的FIFO双向队列结构来实现线程排队获取int变量的同步状态,以此奠定了很多并发包中大部分实现基 ...
- 学习JUC源码（3）——Condition等待队列（源码分析结合图文理解）
前言 在Java多线程中的wait/notify通信模式结尾就已经介绍过,Java线程之间有两种种等待/通知模式,在那篇博文中是利用Object监视器的方法(wait(),notify().notif ...
- 基于wtforms源码实现自定义form组件
from flask import Flask,Markup,render_template,request,redirect from wtforms.form import Form from w ...
- 基于Django Form源码开发自定义Form组件
import copy import re class ValidateError(Exception): def __init__(self, detail): self.detail = deta ...
- JUC源码学习笔记2——AQS共享和Semaphore，CountDownLatch
本文主要讲述AQS的共享模式,共享和独占具有类似的套路,所以如果你不清楚AQS的独占的话,可以看我的<JUC源码学习笔记1> 主要参考内容有<Java并发编程的艺术>,< ...
- JUC源码学习笔记5——线程池，FutureTask，Executor框架源码解析
JUC源码学习笔记5--线程池,FutureTask,Executor框架源码解析 源码基于JDK8 参考了美团技术博客 https://tech.meituan.com/2020/04/02/jav ...
- JUC源码学习笔记4——原子类，CAS，Volatile内存屏障，缓存伪共享与UnSafe相关方法
JUC源码学习笔记4--原子类,CAS,Volatile内存屏障,缓存伪共享与UnSafe相关方法 volatile的原理和内存屏障参考<Java并发编程的艺术> 原子类源码基于JDK8 ...
- Android菜鸟的成长笔记（6）——剖析源码学自定义主题Theme
原文:Android菜鸟的成长笔记(6)--剖析源码学自定义主题Theme 还记得在Android菜鸟的成长笔记(3)中我们曾经遇到了一个问题吗?"这个界面和真真的QQ界面还有点不同的就是上 ...
- JUC源码分析-集合篇（九）SynchronousQueue
JUC源码分析-集合篇(九)SynchronousQueue SynchronousQueue 是一个同步阻塞队列,它的每个插入操作都要等待其他线程相应的移除操作,反之亦然.SynchronousQu ...
随机推荐
- IP 层收发报文简要剖析6--ip_forward 报文转发
//在函数ip_route_input_slow->ip_mkroute_input注册, /* * IP数据包的转发是由ip_forward()处理,该函数在ip_rcv_finish() * ...
- uboot分析——预备知识
1. 刷机 刷机是使用fastboot,所以板子首先要已经能运行uboot,若ROM没有uboot,则使用sd卡或usb启动uboot. 板子进入uboot后,输入fastboot命令,进入fastb ...
- spring boot 视频截图
- mysql调优从书写sql开始
理论知识 MySQL 的运行机制 Mysql 的SQL关键字执行顺序 1.MySQL 的优化方案有哪些? MySQL 数据库常见的优化手段分为三个层面:SQL 和索引优化.数据库结构优化.系统硬件优化 ...
- ceph打印出每秒的IO和pg状态
前言 在ceph 的jewel版本以及之前的版本,通过ceph -w命令是可以拿到每秒钟ceph集群的io状态的,现在的版本是ceph -s一秒秒手动去刷,ceph -w也不监控io的状态了,有的时候 ...
- Cisco思科模拟器路由器各个端口IP地址的配置及路由协议RIP的配置 入门详解 - 精简归纳
Cisco思科模拟器路由器各个端口IP地址的配置及路由协议RIP的配置 入门详解 - 精简归纳 JERRY_Z. ~ 2020 / 11 / 21 转载请注明出处!️ 附: 交流方式: ️ ️ ️ Q ...
- 前端web安全-CSRF基础入门
前言 今天找了个新地方进行学习 嘿嘿 采光不错!特别适合看书呢. 前言 1.CSRF 跨站请求伪造(英语:Cross-site request forgery),也被称为 one-click att ...
- 使用 Docker 部署 Spring Boot 项目，带劲！！
上一篇:年轻人的第一个 Docker 应用 Docker 一次构建.处处运行及快速启停的特性,在微服务架构中有着举足轻重的地位,具体的概念性的东西就不介绍了,不懂的点击这里阅读 Docker 基础教程 ...
- CorelDRAW中的3D线条表现方法
CorelDRAW图形设计工具的最优势之一是其强大的交互式工具. 调和工具就是这样一种互动性很强的工具,从表面上看来可能不是那么突出,但功能是真的强啊!一旦发现它的潜力,它很快就会成为经验丰富的Cor ...
- Sound Forge批量转换音频格式，实现高效编辑音频
Sound Forge的批量处理功能可以实现批量格式转换.批量添加效果等功能,让用户可以在处理其他音频编辑任务的同时,自动完成格式转换.效果添加等重复性任务.接下来,一起来看看如何借助批处理转换器实现 ...