Skip to content

Commit 10528fe

Browse files
committed
📝 Writing docs.
1 parent b5e646e commit 10528fe

4 files changed

Lines changed: 87 additions & 445 deletions

File tree

Lines changed: 56 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,56 @@
1+
---
2+
title: Java并发容器
3+
date: 2018/05/15
4+
categories:
5+
- javase
6+
tags:
7+
- javase
8+
- concurrent
9+
- juc
10+
---
11+
12+
# Java 并发容器
13+
14+
> 本文内容基于 JDK1.8。
15+
16+
<!-- TOC depthFrom:2 depthTo:3 -->
17+
18+
- [概述](#概述)
19+
- [ConcurrentHashMap](#concurrenthashmap)
20+
- [CopyOnWriteArrayList](#copyonwritearraylist)
21+
- [资料](#资料)
22+
23+
<!-- /TOC -->
24+
25+
## 概述
26+
27+
JDK 的 `java.util.concurrent` 包(即 juc)中提供了几个非常有用的并发容器。
28+
29+
| 类名 | 类型 | 功能 |
30+
| --------------------- | ----- | --------------------------------------------------------------------------------------------------- |
31+
| CopyOnWriteArrayList | List | 线程安全的 ArrayList |
32+
| CopyOnWriteArraySet | Set | 线程安全的 Set,它内部包含了一个 CopyOnWriteArrayList,因此本质上是由 CopyOnWriteArrayList 实现的。 |
33+
| ConcurrentSkipListSet | Set | 相当于线程安全的 TreeSet。它是有序的 Set。它由 ConcurrentSkipListMap 实现。 |
34+
| ConcurrentHashMap | Map | 线程安全的 HashMap。采用分段锁实现高效并发。 |
35+
| ConcurrentSkipListMap | Map | 线程安全的有序 Map。使用跳表实现高效并发。 |
36+
| ConcurrentLinkedQueue | Queue | 线程安全的无界队列。底层采用单链表。支持 FIFO。 |
37+
| ConcurrentLinkedDeque | Queue | 线程安全的无界双端队列。底层采用双向链表。支持 FIFO 和 FILO。 |
38+
| ArrayBlockingQueue | Queue | 数组实现的阻塞队列。 |
39+
| LinkedBlockingQueue | Queue | 链表实现的阻塞队列。 |
40+
| LinkedBlockingDeque | Queue | 双向链表实现的双端阻塞队列。 |
41+
42+
## ConcurrentHashMap
43+
44+
* 作用:ConcurrentHashMap 是线程安全的 HashMap。
45+
* 原理:ConcurrentHashMap 采用了分段锁机制实现高效的并发访问。
46+
47+
## CopyOnWriteArrayList
48+
49+
* 作用:CopyOnWrite 字面意思为写入时复制。CopyOnWriteArrayList 是线程安全的 ArrayList。
50+
* 原理:写入时复制(CopyOnWrite)容器的迭代器保留一个指向底层基础数组的引用,这个数组当前位于迭代器的起始位置,由于它不会被修改,因此在对其进行同步时只需确保数组内容的可见性。
51+
52+
## 资料
53+
54+
* [Java 并发编程实战](https://item.jd.com/10922250.html)
55+
* [Java 并发编程的艺术](https://item.jd.com/11740734.html)
56+
* https://blog.csdn.net/u010425776/article/details/54890215

‎docs/concurrent/Java并发工具类.md‎

Lines changed: 26 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -15,19 +15,19 @@ tags:
1515
1616
<!-- TOC depthFrom:2 depthTo:3 -->
1717

18-
- [CountDownLatch](#countdownlatch)
19-
- [要点](#要点)
20-
- [源码](#源码)
21-
- [示例](#示例)
22-
- [CyclicBarrier](#cyclicbarrier)
23-
- [要点](#要点-1)
24-
- [源码](#源码-1)
25-
- [示例](#示例-1)
26-
- [Semaphore](#semaphore)
27-
- [要点](#要点-2)
28-
- [源码](#源码-2)
29-
- [示例](#示例-2)
30-
- [资料](#资料)
18+
* [CountDownLatch](#countdownlatch)
19+
* [要点](#要点)
20+
* [源码](#源码)
21+
* [示例](#示例)
22+
* [CyclicBarrier](#cyclicbarrier)
23+
* [要点](#要点-1)
24+
* [源码](#源码-1)
25+
* [示例](#示例-1)
26+
* [Semaphore](#semaphore)
27+
* [要点](#要点-2)
28+
* [源码](#源码-2)
29+
* [示例](#示例-2)
30+
* [资料](#资料)
3131

3232
<!-- /TOC -->
3333

@@ -37,16 +37,16 @@ JDK 的 `java.util.concurrent` 包(即 juc)中提供了几个非常有用的
3737

3838
### 要点
3939

40-
* 作用:允许一个或多个线程等待,直到在其他线程中执行的一组操作完成。
41-
* 原理:`CountDownLatch` 维护一个计数器 count。每次调用 `countDown` 方法会让 count 的值减 1,减到 0 的时候,那些因为调用 `await` 方法而在等待的线程就会被唤醒。
40+
* 作用:字面意思为递减计数锁。它允许一个或多个线程等待,直到在其他线程中执行的一组操作完成。
41+
* 原理:`CountDownLatch` 维护一个计数器 count,表示需要等待的事件数量。`countDown` 方法递减计数器,表示有一个事件已经发生。调用 `await` 方法的线程会一直阻塞直到计数器为零,或者等待中的线程中断,或者等待超时。
4242

4343
<p align="center">
4444
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/CountdownLatch.png" alt="CountdownLatch">
4545
</p>
4646

4747
### 源码
4848

49-
`CountDownLatch` 唯一的构造器:
49+
`CountDownLatch` 唯一的构造方法:
5050

5151
```java
5252
// 初始化计数器
@@ -110,16 +110,17 @@ public class CountDownLatchDemo {
110110

111111
### 要点
112112

113-
* 作用:字面意思回环栅栏,通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后,`CyclicBarrier` 可以被重用。
113+
* 作用:字面意思循环栅栏。它可以让一组线程等待至某个状态之后再全部同时执行。叫做循环是因为当所有等待线程都被释放以后,`CyclicBarrier` 可以被重用。
114114
* 原理:`CyclicBarrier` 维护一个计数器 count。每次执行 `await` 方法之后,count 加 1,直到计数器的值和设置的值相等,等待的所有线程才会继续执行。
115+
* 场景:`CyclicBarrier` 在并行迭代算法中非常有用。
115116

116117
<p align="center">
117118
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/CyclicBarrier.png" alt="CyclicBarrier">
118119
</p>
119120

120121
### 源码
121122

122-
`CyclicBarrier` 提供了 2 个构造器
123+
`CyclicBarrier` 提供了 2 个构造方法
123124

124125
```java
125126
// parties 数相当于一个屏障,当 parties 数量的线程在等待时会跳闸,并且在跳闸时不执行预定义的动作。
@@ -196,16 +197,19 @@ public class CyclicBarrierDemo02 {
196197

197198
### 要点
198199

199-
* 作用:字面意思为信号量。`Semaphore` 可以控制同时访问的线程个数。
200-
* 原理:`Semaphore` 初始化固定数量的 permit。每次执行 `acquire` 方法可以获取一个 permit,如果没有就等待;而 `release` 方法可以释放一个 permit。
200+
* 作用:字面意思为信号量。`Semaphore` 用来控制同时访问某个特定资源的操作数量,或者同时执行某个指定操作的数量。
201+
* 原理:`Semaphore` 管理着一组虚拟的许可(permit),permit 的初始数量可通过构造方法来指定。每次执行 `acquire` 方法可以获取一个 permit,如果没有就等待;而 `release` 方法可以释放一个 permit。
202+
* 场景:
203+
* `Semaphore` 可以用于实现资源池,如数据库连接池。
204+
* `Semaphore` 可以用于将任何一种容器变成有界阻塞容器。
201205

202206
<p align="center">
203207
<img src="https://raw.githubusercontent.com/dunwu/javase-notes/master/images/concurrent/semaphore.png" alt="semaphore">
204208
</p>
205209

206210
### 源码
207211

208-
`Semaphore`提供了 2 个构造器:
212+
`Semaphore`提供了 2 个构造方法:
209213

210214
```java
211215
// 初始化固定数量的 permit,并且默认为非公平模式
@@ -260,4 +264,4 @@ public class SemaphoreDemo {
260264

261265
* [Java 并发编程实战](https://item.jd.com/10922250.html)
262266
* [Java 并发编程的艺术](https://item.jd.com/11740734.html)
263-
* [Java 并发编程:CountDownLatch、CyclicBarrier 和 Semaphore](http://www.cnblogs.com/dolphin0520/p/3920397.html)
267+
* http://www.cnblogs.com/dolphin0520/p/3920397.html

‎docs/concurrent/README.md‎

Lines changed: 5 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
# 并发
22

3-
## 附录
3+
## 目录
44

5-
[并发术语](并发术语.md)
6-
[Java并发面试](Java并发面试.md)
7-
[Java并发工具类](Java并发工具类.md)
5+
* [Java 并发容器](Java并发容器.md)
6+
* [Java 并发工具类](Java并发工具类.md)
7+
* [Java 并发面试](Java并发面试.md)
8+
* [并发术语](并发术语.md)

0 commit comments

Comments
 (0)