Skip to content

Commit affd68c

Browse files
author
代码风水师
committed
添加了大量多线程与并发框架的文章
1 parent b6fe98c commit affd68c

19 files changed

Lines changed: 897 additions & 22 deletions

‎README.md‎

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@
2828
* 2. [Java虚拟机 (第 02 篇) 深入理解:堆内存]()
2929
* 3. [Java虚拟机 (第 03 篇) 深入理解:垃圾收集算法]()
3030
* 4. [Java虚拟机 (第 04 篇) 深入理解:垃圾收集器]()
31-
* 5. [Java虚拟机 (第 05 篇) 深入理解:jdk内存分析命令]()
31+
* 5. [Java虚拟机 (第 05 篇) 深入理解:jvm内存分析命令]()
3232
* 6. Java虚拟机 (第 06 篇) 深入理解:内存调优
3333
* 7. Java虚拟机 (第 07 篇) 深入理解:死锁、CPU飙升与OOM排除过程
3434
* 8. Java虚拟机 (第 08 篇) 深入理解:类文件结构
@@ -38,24 +38,24 @@
3838
* 12. Java虚拟机 (第 12 篇) 深入理解:OSGi与Tomcat类加载机制
3939

4040

41-
### 三、:closed_lock_with_key:Java多线程与并发框架:unlock:![Progress](http://progressed.io/bar/0)
42-
* 1. Java多线程与并发框 (第 01 篇) 深入理解:线程的状态
43-
* 2. Java多线程与并发框 (第 02 篇) 深入理解:Java内存模型
44-
* 3. Java多线程与并发框 (第 03 篇) 深入理解:Java内存模型的三大特性 -- 原子性、可见性、有序性
45-
* 4. Java多线程与并发框 (第 04 篇) 深入理解:重排序、屏障指令、as-if-serial、happens-before规则
46-
* 5. Java多线程与并发框 (第 05 篇) 深入理解:顺序一致性模型
47-
* 6. Java多线程与并发框 (第 06 篇) 深入理解:volatile 关键字
48-
* 7. Java多线程与并发框 (第 07 篇) 深入理解:synchronized 关键字
49-
* 8. Java多线程与并发框 (第 08 篇) 深入理解:final 关键字
50-
* 9. Java多线程与并发框 (第 09 篇) 深入理解:锁
51-
* 10. Java多线程与并发框 (第 10 篇) 深入理解:无锁化 CAS
52-
* 11. Java多线程与并发框 (第 11 篇) 深入理解:同步队列器 AQS
53-
* 12. Java多线程与并发框 (第 12 篇) 深入理解:并发辅助工具类
54-
* 13. Java多线程与并发框 (第 13 篇) 深入理解:定时器
55-
* 14. Java多线程与并发框 (第 14 篇) 深入理解:ForkJoin框架
56-
* 15. Java多线程与并发框 (第 15 篇) 深入理解:原子操作
57-
* 16. Java多线程与并发框 (第 16 篇) 深入理解:线程池
58-
* 17. Java多线程与并发框 (第 16 篇) 深入理解:ThreadLocal
41+
### 三、:closed_lock_with_key:Java多线程与并发框架:unlock:![Progress](http://progressed.io/bar/35)
42+
* 1. [Java多线程与并发框 (第 01 篇) 深入理解:线程的状态]()
43+
* 2. [Java多线程与并发框 (第 02 篇) 深入理解:Java内存模型]()
44+
* 3. [Java多线程与并发框 (第 03 篇) 深入理解:Java内存模型的三大特性 -- 原子性、可见性、有序性]()
45+
* 4. [Java多线程与并发框 (第 04 篇) 深入理解:重排序、屏障指令、as-if-serial、happens-before规则]()
46+
* 5. [Java多线程与并发框 (第 05 篇) 深入理解:顺序一致性模型]()
47+
* 6. [Java多线程与并发框 (第 06 篇) 深入理解:volatile 关键字]()
48+
* 7. [Java多线程与并发框 (第 07 篇) 深入理解:synchronized 关键字]()
49+
* 8. [Java多线程与并发框 (第 08 篇) 深入理解:final 关键字]()
50+
* 9. [Java多线程与并发框 (第 09 篇) 深入理解:Java各种锁与无锁]()
51+
* 10. [Java多线程与并发框 (第 10 篇) 深入理解:CAS]()
52+
* 11. [Java多线程与并发框 (第 11 篇) 深入理解:并发包的基石 -- 队列同步器 AQS]()
53+
* 12. [Java多线程与并发框 (第 12 篇) 深入理解:并发辅助工具类(很好的玩的工具类)]()
54+
* 13. [Java多线程与并发框 (第 12 篇) 深入理解:线程池]()
55+
* 14. [Java多线程与并发框 (第 13 篇) 深入理解:定时/计划任务]()
56+
* 15. [Java多线程与并发框 (第 14 篇) 深入理解:ForkJoin框架]()
57+
* 16. [Java多线程与并发框 (第 15 篇) 深入理解:原子操作]()
58+
* 17. [Java多线程与并发框 (第 16 篇) 深入理解:ThreadLocal]()
5959

6060

6161
### 四、:satellite::satellite::satellite:网络协议:globe_with_meridians::globe_with_meridians::globe_with_meridians:![Progress](http://progressed.io/bar/0)
Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,5 @@
1+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">类文件结构</h3>
2+
3+
4+
5+
Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">类加载机制</h3>
2+
3+
从写好的代码到被执行完成,这都与类加载器机制密不可分。就像我们吃食物一样,先用筷子/勺子/叉子将食物放入嘴中,然后通过舌头上的味觉器官验证食物好不好吃、有没有变馊。
4+
5+
首先, Java 编译器将Java源代码(.java 文件)编译成 Java字节码(.class 文件)。类加载器负责读取 .class 文件,并转换成 `java.lang.Class`类的一个实例。每个这样的实例用来表示一个 class类。所有的类加载器都是 `java.lang.ClassLoader`类的一个实例。
6+
7+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">一、类加载过程</h3>
8+
9+
![类加载过程](https://upload-images.jianshu.io/upload_images/11476758-1bc7770bbd72e069.png)
10+
11+
#### 1.1、加载
12+
13+
14+
15+
#### 1.2、验证
16+
17+
18+
19+
#### 1.3、准备
20+
21+
22+
23+
#### 1.4、解析
24+
25+
26+
27+
#### 1.5、初始化
28+
29+
30+
31+
#### 1.6、使用
32+
33+
34+
35+
#### 1.7、卸载
36+
37+
38+
39+
40+
41+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">二、双亲委派模型</h3>
42+
43+
44+
45+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">三、Tomcat类加载器</h3>
46+
47+
48+
49+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">四、OSGi:Java动态化模块化</h3>

‎resource/markdown/jvm/JVMMemoryAnalysisCommand.md‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -271,8 +271,14 @@ KiB Swap: 0 total, 0 free, 0 used. 414824 avail Mem
271271
#### top -d -n -p 有参
272272

273273
```shell
274-
$ top -d 5 -n 20 -p 2395
275-
274+
$ top -d 5 -n 20 -p 2395 # 表示每5秒分析一次,共动态分析20词,监视的进程号2395
275+
top - 09:30:02 up 207 days, 19:35, 2 users, load average: 0.00, 0.02, 0.05
276+
Tasks: 1 total, 0 running, 1 sleeping, 0 stopped, 0 zombie
277+
%Cpu(s): 1.0 us, 0.3 sy, 0.0 ni, 98.7 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
278+
KiB Mem : 16267428 total, 175448 free, 15553816 used, 538164 buff/cache
279+
KiB Swap: 0 total, 0 free, 0 used. 382452 avail Mem
276280

281+
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
282+
2395 root 20 0 9382196 1.807g 6252 S 7.4 11.6 1270:55 java
277283
```
278284

‎resource/markdown/multithread/ThreadStatus.md‎

Lines changed: 0 additions & 1 deletion
This file was deleted.
Lines changed: 167 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,167 @@
1+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">并发包的基石 -- 队列同步器 AQS</h3>
2+
3+
#### 本文关注点
4+
* **AbstractOwnableSynchronizer** 抽象的、可拥有的同步器
5+
* `★★★★★`**AbstractQueuedSynchronizer**抽象的、队列(排队)的同步器
6+
* **Sync** 同步
7+
* **FairSync** 公平同步
8+
* **NonfairSync** 非公平同步
9+
10+
---
11+
![AQS](https://upload-images.jianshu.io/upload_images/11476758-15ca6a3e1415a256.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
12+
13+
14+
#### 一、 `AbstractOwnableSynchronizer` 抽象的、可拥有的同步器
15+
![AbstractOwnableSynchronizer的方法与属性](https://upload-images.jianshu.io/upload_images/11476758-f0950e50411f1845.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
16+
17+
* **源码分析:**
18+
```java
19+
package java.util.concurrent.locks;
20+
21+
/**
22+
* 可由线程独占的同步器。
23+
* 该类为创建锁和相关的同步器提供了基础,可能需要拥有所有权的概念。
24+
* AbstractOwnableSynchronizer 类本身不管理或使用此信息。
25+
* 但是,子类和工具可以使用适当维护的值来帮助控制和监视访问并提供诊断。
26+
*
27+
* @since 1.6
28+
* @author Doug Lea
29+
*/
30+
public abstract class AbstractOwnableSynchronizer
31+
implements java.io.Serializable {
32+
33+
/** 即使所有的字段都是短暂的(被禁止序列化的),也要使用 序列ID。*/
34+
private static final long serialVersionUID = 3737899427754241961L;
35+
36+
/**
37+
* 供子类使用的空的构造方法。
38+
*/
39+
protected AbstractOwnableSynchronizer() { }
40+
41+
/**
42+
* 独占模式同步下的当前(线程)拥有者。(也就是当前独占锁的线程)
43+
*/
44+
private transient Thread exclusiveOwnerThread;
45+
46+
/**
47+
* 设置 当前拥有独占访问的 线程。
48+
* 空参数指示没有线程拥有访问权限。
49+
* 此方法不另外施加任何同步化易失性 volatile 字段访问。
50+
* @param thread 所有者的线程(拥有当前独占访问权的线程)
51+
*/
52+
protected final void setExclusiveOwnerThread(Thread thread) {
53+
exclusiveOwnerThread = thread;
54+
}
55+
56+
/**
57+
* 返回 setExclusiveOwnableThread(Thread thread) 方法最后设置的线程,
58+
* 如果从未设置,则返回 null。
59+
* 此方法不另外施加任何同步化易失性 volatile 字段访问。
60+
* @return 所有者的线程(拥有当前独占访问权的线程)
61+
*/
62+
protected final Thread getExclusiveOwnerThread() {
63+
return exclusiveOwnerThread;
64+
}
65+
}
66+
```
67+
> **小结:**
68+
> **独占、持有锁的线程成员变量:Thread exclusiveOwnerThread**
69+
> **setExclusiveOwnerThread(Thread thread)** 设置独占、持有锁的线程成员变量
70+
> **getExclusiveOwnerThread()** 获得独占、持有锁的线程成员变量
71+
72+
73+
#### 二、 `AbstractQueuedSynchronizer` 抽象、队列同步器 AQS
74+
![AbstractQueueSynchronizer公有属性和公有方法.png](https://upload-images.jianshu.io/upload_images/11476758-10ff5c98c4f752a9.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
75+
76+
![AbstractQueuedSynchronizer 私有方法.png](https://upload-images.jianshu.io/upload_images/11476758-b373d216213b6845.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
77+
78+
![AbstractQueuedSynchronizer final域与私有域.png](https://upload-images.jianshu.io/upload_images/11476758-4e2da27a6904ad4d.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
79+
80+
* **AbstractQueuedSynchronizer 简介**
81+
> 提供了一个基于 **FIFO队列**,可以用于构建锁或者其他相关同步装置的基础框架。该 **抽象队列同步器**(以下简称**队列同步器**)利用了一个 **private volatile int state**来表示 **同步状态**,期望它能够成为实现大部分同步需求的基础。使用的方法是继承,子类通过继承同步器并需要实现它的方法来管理其状态,管理的方式就是通过类似 **acquire获取** 和 **release释放** 的方式来 **操纵状态**。然而 **多线程环境中对状态的操纵必须确保原子性**,因此子类对于状态的把握,需要使用这个同步器提供的以下三个方法对状态进行操作:
82+
> * private volatile int **state**;
83+
> * java.util.concurrent.locks.AbstractQueuedSynchronizer.**getState()**
84+
> * java.util.concurrent.locks.AbstractQueuedSynchronizer.**setState(int newState)**
85+
> * java.util.concurrent.locks.AbstractQueuedSynchronizer.**compareAndSetState(int expect, int update)**
86+
* **2.1、源码分析:**
87+
```
88+
/**
89+
* 返回同步状态的当前值。
90+
* 此操作具有易失性 volatile 读取的内存语义。
91+
* @return 当前 state 的值
92+
*/
93+
protected final int getState() {
94+
return state;
95+
}
96+
97+
// ------------------- 华丽的分割线 -------------------
98+
/**
99+
* 设置同步状态 state 的值。
100+
* 此操作具有易失性 volatile 写的内存语义。
101+
* @param newState 状态 state 的新值
102+
*/
103+
protected final void setState(int newState) {
104+
state = newState;
105+
}
106+
107+
// ------------------- 华丽的分割线 -------------------
108+
/**
109+
* 如果当前状态值等于预期值,则以原子方式将同步状态设置为给定的更新值。
110+
* 此操作具有易失性 volatile 读取和写入的内存语义。
111+
*
112+
* @param expect 期望的值
113+
* @param update 新值
114+
* @return 如果成功则为 true 。 错误返回表示实际值不等于预期值的指示。
115+
*/
116+
protected final boolean compareAndSetState(int expect, int update) {
117+
// See below for intrinsics setup to support this
118+
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
119+
}
120+
```
121+
122+
* **2.2、FIFO 队列** (类似双向链表)
123+
> 同步器的开始提到了其实现依赖于一个 **FIFO 队列**,那么队列中的 **元素节点Node** 就是保存着 **线程引用** 和 **线程状态** 的 **容器**,**每个线程对同步器的访问,都可以看做是队列中的一个节点Node**。Node的主要包含以下成员变量:
124+
```
125+
static final class Node {
126+
/** 作为标记表示节点正在 共享模式 中等待 */
127+
static final Node SHARED = new Node();
128+
/** 作为标记表示节点正在 独占模式 下等待 */
129+
static final Node EXCLUSIVE = null;
130+
131+
int waitStatus;
132+
volatile Node prev;
133+
volatile Node next;
134+
volatile Thread thread;
135+
volatile Node nextWaiter;
136+
137+
final boolean isShared() {
138+
return nextWaiter == SHARED;
139+
}
140+
}
141+
```
142+
* **2.3、API**
143+
144+
| 方法名称 | 描述 |
145+
| ------ | ------- |
146+
| protected boolean tryAcquire(int arg) | 独占式获取锁,实现该方法需要查询当前状态并判断同步状态是否和预期值相同,然后使用 CAS 操作设置同步状态 |
147+
| protected boolean tryRelease(int arg) | 独占式释放锁,实际也是修改同步变量 |
148+
| protected int tryAcquireShared(int arg) | 共享式获取锁,返回大于等于 0 的值,表示获取锁成功,反之获取失败 |
149+
| protected boolean tryReleaseShared(int arg) | 共享式释放锁 |
150+
| protected boolean isHeldExclusively() | 判断调用该方法的线程是否持有互斥锁 |
151+
152+
* **其他重要方法**
153+
> private Node **addWaiter(Node mode)**
154+
155+
> 参考资料:
156+
> [AbstractQueuedSynchronizer的介绍和原理分析](http://ifeve.com/introduce-abstractqueuedsynchronizer/)
157+
158+
---
159+
##### 三、 `Sync`抽象的静态内部类
160+
![Sync 静态内部类的方法与属](https://upload-images.jianshu.io/upload_images/11476758-9430f3ace4f38a69.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
161+
162+
163+
##### 四、 `FairSync` 公平锁(静态内部类)
164+
![FairSync 公平同步器](https://upload-images.jianshu.io/upload_images/11476758-3feff7da83e0a35c.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
165+
166+
##### 五、 `NonfairSync` 非公平锁(静态内部类)
167+
![NonfairSync 非公平同步器](https://upload-images.jianshu.io/upload_images/11476758-453881e169960163.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
Lines changed: 31 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,31 @@
1+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">CAS实现原理</h3>
2+
3+
> **CAS** 是 **CompareAndSwap** 的缩写,意思是 **比较** 并 **交换**。 它是无锁化的实现是经典的乐观锁。
4+
>
5+
> **CAS** 操作很简单,它包含三个操作数:**内存地址V**、**预期原值A**、**新值B**。先比较内存地址V处的值与预期原值A是否相等,如果相等就将内存地址V处更新为新值B。在配合循环使用时,若CAS操作失败,会循环执行或到达某个终止处。此操作配合 **循环** 使用时,又称为 **自旋锁** 的实现方式。
6+
7+
8+
9+
<h3 style="padding-bottom:6px; padding-left:20px; color:#ffffff; background-color:#E74C3C;">CAS存在的问题</h3>
10+
11+
#### 1、ABA的问题
12+
13+
> 比如一个线程操作时,先将内存地址V处的值A更新为值B,然后又将值B更新为值A。最后CAS判断内存地址V处的没有变化,认为操作更新未成功,但实质上是已经更新过了。这就是经典的 **ABA问题**。
14+
15+
**解决方法**:
16+
17+
①加时间戳:
18+
19+
**②加版本号**:
20+
21+
22+
23+
#### 2、循环开销大
24+
25+
> **CAS** 这种也是乐观锁,如果线程较多、资源抢占激烈、命中率低的情况下,不断的循环会不断的消耗资源。实现上,可以设置最大循环数,达到最大循环数还没有占有资源就自动放弃,避免无限的循环。
26+
27+
28+
29+
#### 3、最多只能保证一个共享变量的操作
30+
31+
> CAS 最多只能操作一个共享变量,单体效率低。

0 commit comments

Comments
 (0)