@@ -10,23 +10,35 @@ tags:
1010
1111# 并发简介
1212
13- <!-- TOC -->
13+ <!-- TOC depthFrom:2 depthTo:4 -->
1414
15- - [ 核心概念 ] ( #核心概念 )
15+ - [ 并发术语 ] ( #并发术语 )
1616 - [ 并发和并行] ( #并发和并行 )
1717 - [ 同步和异步] ( #同步和异步 )
1818 - [ 阻塞和非阻塞] ( #阻塞和非阻塞 )
1919 - [ 进程和线程] ( #进程和线程 )
2020- [ 多线程的优点] ( #多线程的优点 )
21+ - [ 更好的资源利用] ( #更好的资源利用 )
22+ - [ 程序设计更简单] ( #程序设计更简单 )
23+ - [ 程序响应更快] ( #程序响应更快 )
2124- [ 多线程的风险] ( #多线程的风险 )
2225 - [ 安全性问题] ( #安全性问题 )
26+ - [ 线程不安全的示例] ( #线程不安全的示例 )
27+ - [ 竞态条件和临界区] ( #竞态条件和临界区 )
2328 - [ 活跃性问题] ( #活跃性问题 )
29+ - [ 死锁(Deadlock)] ( #死锁deadlock )
30+ - [ 活锁(Livelock)] ( #活锁livelock )
31+ - [ 饥饿(Starvation)] ( #饥饿starvation )
2432 - [ 性能问题] ( #性能问题 )
33+ - [ 上下文切换] ( #上下文切换 )
34+ - [ 资源限制] ( #资源限制 )
2535- [ 资料] ( #资料 )
2636
2737<!-- /TOC -->
2838
29- ## 核心概念
39+ ## 并发术语
40+
41+ 学习并发编程,免不了大量接触一些术语。其中,有些术语经常容易被混淆或分不清它们的差异,这里汇总一下。
3042
3143### 并发和并行
3244
4052 * 最关键的点就是:是否是** 同时** 。
4153
4254<p align =" center " >
43- <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/concurrent-vs-parallel.jpg " alt = " concurrent-vs-parallel " >
55+ <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/concurrent-vs-parallel.jpg " >
4456</p >
4557
4658### 同步和异步
5365 * 异步则是相反,调用在发出之后,这个调用就直接返回了,所以没有返回结果。换句话说,当一个异步过程调用发出后,调用者不会立刻得到结果。而是在调用发出后,被调用者通过状态、通知来通知调用者,或通过回调函数处理这个调用。
5466
5567<p align =" center " >
56- <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/synchronous-vs-asynchronous.gif " alt = " synchronous-vs-asynchronous " >
68+ <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/synchronous-vs-asynchronous.gif " >
5769</p >
5870
5971### 阻塞和非阻塞
7991 * 进程是一个实体,拥有独立的资源;而同一个进程中的多个线程共享进程的资源。
8092
8193<p align =" center " >
82- <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/processes-vs-threads.jpg " alt = " processes-vs-threads " >
94+ <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/processes-vs-threads.jpg " >
8395</p >
8496
8597JVM 在单个进程中运行,JVM 中的线程共享属于该进程的堆。这就是为什么几个线程可以访问同一个对象。线程共享堆并拥有自己的堆栈空间。这是一个线程如何调用一个方法以及它的局部变量是如何保持线程安全的。但是堆不是线程安全的并且为了线程安全必须进行同步。
@@ -90,6 +102,63 @@ JVM 在单个进程中运行,JVM 中的线程共享属于该进程的堆。这
90102* 更简单的编程模型
91103* 程序响应更灵敏
92104
105+ ### 更好的资源利用
106+
107+ 想象一下,一个应用程序需要从本地文件系统中读取和处理文件的情景。比方说,从磁盘读取一个文件需要 5 秒,处理一个文件需要 2 秒。处理两个文件则需要:
108+
109+ ```
110+ 5秒读取文件A
111+ 2秒处理文件A
112+ 5秒读取文件B
113+ 2秒处理文件B
114+ ---------------------
115+ 总共需要14秒
116+ ```
117+
118+ 从磁盘中读取文件的时候,大部分的 CPU 时间用于等待磁盘去读取数据。在这段时间里,CPU 非常的空闲。它可以做一些别的事情。通过改变操作的顺序,就能够更好的使用 CPU 资源。看下面的顺序:
119+
120+ ```
121+ 5秒读取文件A
122+ 5秒读取文件B + 2秒处理文件A
123+ 2秒处理文件B
124+ ---------------------
125+ 总共需要12秒
126+ ```
127+
128+ CPU 等待第一个文件被读取完。然后开始读取第二个文件。当第二文件在被读取的时候,CPU 会去处理第一个文件。记住,在等待磁盘读取文件的时候,CPU 大 部分时间是空闲的。
129+
130+ 总的说来,CPU 能够在等待 IO 的时候做一些其他的事情。这个不一定就是磁盘 IO。它也可以是网络的 IO,或者用户输入。通常情况下,网络和磁盘的 IO 比 CPU 和内存的 IO 慢的多。
131+
132+ ### 程序设计更简单
133+
134+ 在单线程应用程序中,如果你想编写程序手动处理上面所提到的读取和处理的顺序,你必须记录每个文件读取和处理的状态。相反,你可以启动两个线程,每个线程处理一个文件的读取和操作。线程会在等待磁盘读取文件的过程中被阻塞。在等待的时候,其他的线程能够使用 CPU 去处理已经读取完的文件。其结果就是,磁盘总是在繁忙地读取不同的文件到内存中。这会带来磁盘和 CPU 利用率的提升。而且每个线程只需要记录一个文件,因此这种方式也很容易编程实现。
135+
136+ ### 程序响应更快
137+
138+ 将一个单线程应用程序变成多线程应用程序的另一个常见的目的是实现一个响应更快的应用程序。设想一个服务器应用,它在某一个端口监听进来的请求。当一个请求到来时,它去处理这个请求,然后再返回去监听。
139+
140+ 服务器的流程如下所述:
141+
142+ ``` java
143+ while (server is active) {
144+ listen for request
145+ process request
146+ }
147+ ```
148+
149+ 如果一个请求需要占用大量的时间来处理,在这段时间内新的客户端就无法发送请求给服务端。只有服务器在监听的时候,请求才能被接收。另一种设计是,监听线程把请求传递给工作者线程(worker thread),然后立刻返回去监听。而工作者线程则能够处理这个请求并发送一个回复给客户端。这种设计如下所述:
150+
151+ ``` java
152+ while (server is active) {
153+ listen for request
154+ hand request to worker thread
155+ }
156+ ```
157+
158+ 这种方式,服务端线程迅速地返回去监听。因此,更多的客户端能够发送请求给服务端。这个服务也变得响应更快。
159+
160+ 桌面应用也是同样如此。如果你点击一个按钮开始运行一个耗时的任务,这个线程既要执行任务又要更新窗口和按钮,那么在任务执行的过程中,这个应用程序看起来好像没有反应一样。相反,任务可以传递给工作者线程(word thread)。当工作者线程在繁忙地处理任务的时候,窗口线程可以自由地响应其他用户的请求。当工作者线程完成任务的时候,它发送信号给窗口线程。窗口线程便可以更新应用程序窗口,并显示任务的结果。对用户而言,这种具有工作者线程设计的程序显得响应速度更快。
161+
93162## 多线程的风险
94163
95164凡事有利有弊,引入多线程除了带来的好处以外,也产生了一些问题:
@@ -143,20 +212,26 @@ A: 回写寄存器值(3)到内存. this.count 现在等于 3
143212
144213#### 竞态条件和临界区
145214
146- 当两个线程竞争同一资源时,如果对资源的访问顺序敏感,就称存在竞态条件。
215+ > ** 竞态条件(Race Condition) ** : 当两个线程竞争同一资源时,如果对资源的访问顺序敏感,就称存在竞态条件。
147216
148- 导致竞态条件发生的代码区称作临界区。
217+ > ** 临界区(Critical Sections) ** : 导致竞态条件发生的代码区称作临界区。
149218
150219上例中 add()方法就是一个临界区,它会产生竞态条件。在临界区中使用适当的同步就可以避免竞态条件。
151220
152221### 活跃性问题
153222
154- #### 死锁
223+ #### 死锁(Deadlock)
155224
156225##### 什么是死锁
157226
158227多个线程互相等待对方释放锁。
159228
229+ 死锁是当线程进入无限期等待状态时发生的情况,因为所请求的锁被另一个线程持有,而另一个线程又等待第一个线程持有的另一个锁。
230+
231+ <p align =" center " >
232+ <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/deadlock.png " >
233+ </p >
234+
160235##### 避免死锁的方法
161236
162237(1)加锁顺序
@@ -184,14 +259,38 @@ A: 回写寄存器值(3)到内存. this.count 现在等于 3
184259* 释放所有锁,回退,并且等待一段随机的时间后重试。这个和简单的加锁超时类似,不一样的是只有死锁已经发生了才回退,而不会是因为加锁的请求超时了。虽然有回退和等待,但是如果有大量的线程竞争同一批锁,它们还是会重复地死锁(编者注:原因同超时类似,不能从根本上减轻竞争)。
185260* 一个更好的方案是给这些线程设置优先级,让一个(或几个)线程回退,剩下的线程就像没发生死锁一样继续保持着它们需要的锁。如果赋予这些线程的优先级是固定不变的,同一批线程总是会拥有更高的优先级。为避免这个问题,可以在死锁发生的时候设置随机的优先级。
186261
187- #### 饥饿和公平
262+ #### 活锁(Livelock)
263+
264+ ##### 什么是活锁?
265+
266+ 活锁是一个递归的情况,两个或更多的线程会不断重复一个特定的代码逻辑。预期的逻辑通常为其他线程提供机会继续支持'this'线程。
267+
268+ 想象这样一个例子:两个人在狭窄的走廊里相遇,二者都很礼貌,试图移到旁边让对方先通过。但是他们最终在没有取得任何进展的情况下左右摇摆,因为他们都在同一时间向相同的方向移动。
269+
270+ <p align =" center " >
271+ <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/livelock.png " >
272+ </p >
273+
274+ 如图所示:两个线程想要通过一个 Worker 对象访问共享公共资源的情况,但是当他们看到另一个 Worker(在另一个线程上调用)也是“活动的”时,它们会尝试将该资源交给其他工作者并等待为它完成。如果最初我们让两名工作人员都活跃起来,他们将会面临活锁问题。
275+
276+ ##### 避免活锁
277+
278+ 没有避免活锁的通用指南,但是在我们改变其他线程也使用的公共对象状态的场景中,例如在上述场景中,我们必须小心 Worker 对象。
279+
280+ #### 饥饿(Starvation)
188281
189282##### 导致饥饿问题的原因
190283
191284* 高优先级线程吞噬所有的低优先级线程的 CPU 时间。
192285* 线程被永久堵塞在一个等待进入同步块的状态,因为其他线程总是能在它之前持续地对该同步块进行访问。
193286* 线程在等待一个本身(在其上调用 wait())也处于永久等待完成的对象,因为其他线程总是被持续地获得唤醒。
194287
288+ <p align =" center " >
289+ <img src =" https://raw.githubusercontent.com/dunwu/javase-notes/master/images/starvation-and-fairness.png " >
290+ </p >
291+
292+ 饥饿问题最经典的例子就是哲学家问题。如图所示:有五个哲学家用餐,每个人要活得两把叉子才可以就餐。当 2、4 就餐时,1、3、5 永远无法就餐,只能看着盘中的美食饥饿的等待着。
293+
195294##### 解决饥饿问题的方法
196295
197296Java 不可能实现 100% 的公平性,我们依然可以通过同步结构在线程间实现公平性的提高。
@@ -240,12 +339,8 @@ Java 不可能实现 100% 的公平性,我们依然可以通过同步结构在
240339* [ Java 并发编程实战] ( https://item.jd.com/10922250.html ) :第 1 章 简介
241340* [ Java 并发编程的艺术] ( https://item.jd.com/11740734.html ) :第 1 章 Java 并发编程的挑战
242341* http://tutorials.jenkov.com/java-concurrency/benefits.html
243- * http://tutorials.jenkov.com/java-concurrency/costs.html
244- * http://tutorials.jenkov.com/java-concurrency/race-conditions-and-critical-sections.html
245- * http://tutorials.jenkov.com/java-concurrency/thread-safety.html
246- * http://tutorials.jenkov.com/java-concurrency/thread-safety-and-immutability.html
247- * http://tutorials.jenkov.com/java-concurrency/deadlock.html
248- * http://tutorials.jenkov.com/java-concurrency/deadlock-prevention.html
249- * http://tutorials.jenkov.com/java-concurrency/starvation-and-fairness.html
342+ * https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/thread-deadlock.html
343+ * https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/thread-livelock.html
344+ * https://www.logicbig.com/tutorials/core-java-tutorial/java-multi-threading/thread-starvation.html
250345* https://www.zhihu.com/question/33515481
251346* https://blog.csdn.net/yaosiming2011/article/details/44280797
0 commit comments