# 写再前面
> 原文链接：https://codeyee.com/archives/java-util-concurrent.html
# 目录
[TOC]
# 具体内容
## 0x01：使用线程的几种方式
有四种使用线程的方法：
- 1、实现 `Runnable` 接口；
- 2、实现 `Callable` 接口；
- 3、继承 `Thread` 类。
- 4、通过线程池的方式去创建线程
实现 `Runnable` 和 `Callable` 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 `Thread` 来调用。可以理解为任务是通过线程驱动从而执行的。
### 实现 Runnable 接口
需要实现接口中的 `run()` 方法，线程的具体操作也体现在该方法内。
```java
public class MyRunnable implements Runnable {
@Override
public void run() {
// ...
}
}
```
使用 Runnable 实例再创建一个 Thread 实例，然后调用 `Thread` 实例的 `start()` 方法来启动线程。
### 实现 Callable 接口
与 Runnable 相比，Callable 可以有返回值，返回值通过 `FutureTask` 进行封装，线程中的具体操作写在 `call` 方法内。
```java
public class MyCallable implements Callable<Integer> {
public Integer call() {
return 123;
}
}
```
```java
public static void main(String[] args) throws ExecutionException, InterruptedException {
MyCallable mc = new MyCallable();
FutureTask<Integer> ft = new FutureTask<>(mc);
Thread thread = new Thread(ft);
thread.start();
System.out.println(ft.get());
}
```
### 继承 Thread 类
同样也是需要实现 `run()` 方法，因为 `Thread` 类也实现了 `Runable` 接口。
当调用 `start()` 方法启动一个线程时，虚拟机会将该线程放入就绪队列中等待被调度，当一个线程被调度时会执行该线程的 `run()` 方法。
```java
public class MyThread extends Thread {
public void run() {
// ...
}
}
```
```java
public static void main(String[] args) {
MyThread mt = new MyThread();
mt.start();
}
```
### 线程池
[线程池的详细使用操作，参考这里](https://codeyee.com/archives/java-thread.html#%E6%96%B9%E5%BC%8F%E5%9B%9B%E7%BA%BF%E7%A8%8B%E6%B1%A0)
### 实现接口 VS 继承 Thread
实现接口会更好一些，因为：
- 由于 `Java` 不支持多重继承，因此继承了 Thread 类就无法继承其它类，但是可以实现多个接口；
- 类可能只要求可执行就行，继承整个 Thread 类开销过大。
## 0x02：基础线程机制
### Executor
`Executor` 管理多个异步任务的执行，而无需程序员显式地管理线程的生命周期。这里的异步是指 **多个任务的执行互不干扰**，不需要进行同步操作。
主要有三种 Executor：
- `CachedThreadPool`：一个任务创建一个线程；
- `FixedThreadPool`：创建固定大小的线程池；
- `SingleThreadExecutor`：相当于大小为 1 的 FixedThreadPool。
[线程池的详细使用操作，参考这里](https://codeyee.com/archives/java-thread.html#%E6%96%B9%E5%BC%8F%E5%9B%9B%E7%BA%BF%E7%A8%8B%E6%B1%A0)
### Daemon
守护线程是程序运行时在后台提供服务的线程，但这不属于程序中不可或缺的部分。
当所有非守护线程结束时，程序也就终止，同时会杀死所有守护线程。
main() 属于非守护线程。
在线程启动之前使用 `setDaemon()` 方法可以将一个线程设置为守护线程。
```java
public static void main(String[] args) {
Thread thread = new Thread(new MyRunnable());
thread.setDaemon(true);
}
```
> 使用场景
- 场景1 主线程 `sleep` 结束后用户线程还是会一直打印 `running`
- 场景2 用户线程设置为守护线程，在主线程sleep后也会一起退出。
- 场景3 在主线程 `sleep` 后设置了标识，子线程跳出循环结束，程序也会退出。
- 场景4 守护线程里产生的线程也是守护线程。
> 守护线程的作用
守护线程的作用是在其它用户线程执行结束后，可以直接结束 `jvm `进程
- 比如有时候我们希望任务在程序退出时不会影响正常退出，或者等待退出。
- 有些时候停一个线程是一个麻烦事，而这个线程被突然中断也不会造成错误或大的影响，就可以使用守护线程。
- 垃圾收集器就是一个守护线程。
### sleep()
Thread.sleep(millisec) 方法会休眠当前正在执行的线程，`millisec` 单位为毫秒。
`sleep()` 可能会抛出 `InterruptedException`，因为异常不能跨线程传播回 main() 中，因此必须在本地进行处理。线程中抛出的其它异常也同样需要在本地进行处理。如下代码所示
```java
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
```
### yield()
对静态方法 `Thread.yield()` 的调用声明了当前线程已经完成了生命周期中最重要的部分，可以切换给其它线程来执行。该方法只是对线程调度器的一个"建议"，而且也只是"建议"具有相同优先级的其它线程可以运行，具体如何进行调度，还是又系统的线程调度器来决定。
```java
public void run() {
Thread.yield();
}
```
## 0x03：中断
一个线程执行完毕之后会自动结束，如果在运行过程中发生异常也会提前结束。
上述情况可以称为 "线程的中断"。
### InterruptedException
通过调用一个线程的 `interrupt()` 来中断该线程，如果该线程处于阻塞、限期等待或者"无限期"等待状态，那么就会抛出 `InterruptedException`，从而提前结束该线程。但是不能中断 `I/O` 阻塞和 `synchronized` 锁阻塞。
对于以下代码，在 `main()` 中启动一个线程之后再中断它，由于线程中调用了 `Thread.sleep()` 方法，因此会抛出一个 `InterruptedException`，从而提前结束线程，不执行之后的语句。如下代码所示
```java
public class InterruptExample {
private static class MyThread1 extends Thread {
@Override
public void run() {
try {
Thread.sleep(2000);
System.out.println("Thread run");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
```
```java
public static void main(String[] args) throws InterruptedException {
Thread thread1 = new MyThread1();
thread1.start();
thread1.interrupt();
System.out.println("Main run");
}
```
执行结果
```java
Main run
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at InterruptExample.lambda$main$0(InterruptExample.java:5)
at InterruptExample$$Lambda$1/713338599.run(Unknown Source)
at java.lang.Thread.run(Thread.java:745)
```
### interrupted()
如果一个线程的 `run()` 方法执行一个无限循环，并且没有执行 `sleep()` 等会抛出 `InterruptedException` 的操作，那么调用线程的 `interrupt()` 方法就无法使线程提前结束。
但是调用 `interrupt()` 方法会设置线程的"中断标记"，此时调用 `interrupted()` 方法会返回 `true`。因此可以在循环体中使用 interrupted() 方法来判断线程是否处于中断状态，从而提前结束线程。
如下代码所示
```java
public class InterruptExample {
private static class MyThread2 extends Thread {
@Override
public void run() {
while (!interrupted()) {
// ..
}
System.out.println("Thread end");
}
}
}
```
```java
public static void main(String[] args) throws InterruptedException {
Thread thread2 = new MyThread2();
thread2.start();
thread2.interrupt();
}
```
执行结果
```html
Thread end
```
### Executor的中断操作
调用 Executor 的 shutdown() 方法会等待线程都执行完毕之后再关闭，但是如果调用的是 `shutdownNow()` 方法，则相当于调用每个线程的 `interrupt()` 方法。
以下使用 `Lambda` 创建线程，相当于创建了一个匿名内部线程。
```java
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> {
try {
Thread.sleep(2000);
System.out.println("Thread run");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
executorService.shutdownNow();
System.out.println("Main run");
}
```
执行结果
```java
Main run
java.lang.InterruptedException: sleep interrupted
at java.lang.Thread.sleep(Native Method)
at ExecutorInterruptExample.lambda$main$0(ExecutorInterruptExample.java:9)
at ExecutorInterruptExample$$Lambda$1/1160460865.run(Unknown Source)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1142)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:617)
at java.lang.Thread.run(Thread.java:745)
```
如果只想中断 Executor 中的一个线程，可以通过使用 `submit()` 方法来提交一个线程，它会返回一个 `Future<?>` 对象，通过调用该对象的 `cancel(true)` 方法就可以中断线程。
## 0x04：互斥同步
Java 提供了两种锁机制来控制多个线程对共享资源的互斥访问，第一个是 `JVM` 实现的 `synchronized`，而另一个是 JDK 实现的 `ReentrantLock`。
### synchronized
**1、同步一个代码块**
```java
public void func() {
synchronized (this) {
// ...
}
}
```
它只作用于同一个对象，如果调用**两个对象**上的同步代码块，就不会进行同步。
如下例子
```java
public class SynchronizedExample {
public void func1() {
synchronized (this) {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
}
}
}
```
```java
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func1());
executorService.execute(() -> e1.func1());
}
```
执行结果
```html
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
```
如上述的代码所示，使用 `ExecutorService` 执行了两个线程，由于调用的是**同一个对象**的同步代码块，因此这两个线程会进行同步，当一个线程进入同步语句块时，另一个线程就必须等待。
对于以下代码，两个线程调用了不同对象的同步代码块，因此这两个线程就不需要同步。从输出结果可以看出，两个线程交叉执行。
```java
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
SynchronizedExample e2 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func1());
executorService.execute(() -> e2.func1());
}
```
执行结果
```html
0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9
```
**2、同步一个方法**
```java
public synchronized void func () {
// ...
}
```
**3、同步一个类**
```java
public void func() {
synchronized (SynchronizedExample.class) {
// ...
}
}
```
作用于整个类，也就是说两个线程调用 **同一个类的不同对象 **上的这种同步语句，也会进行同步。如下代码所示
```java
public class SynchronizedExample {
public void func2() {
synchronized (SynchronizedExample.class) {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
}
}
}
```
```java
public static void main(String[] args) {
SynchronizedExample e1 = new SynchronizedExample();
SynchronizedExample e2 = new SynchronizedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> e1.func2());
executorService.execute(() -> e2.func2());
}
```
执行结果
```html
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
```
**4、同步一个静态方法**
```java
public synchronized static void fun() {
// ...
}
```
同步一个静态方法也会作用于整个类的所有对象。
### ReentrantLock
ReentrantLock 是 `java.util.concurrent（J.U.C）`包中的锁。
如下代码所示
```java
public class LockExample {
private Lock lock = new ReentrantLock();
public void func() {
lock.lock();
try {
for (int i = 0; i < 10; i++) {
System.out.print(i + " ");
}
} finally {
lock.unlock(); // 确保释放锁，从而避免发生死锁。
}
}
}
```
```java
public static void main(String[] args) {
LockExample lockExample = new LockExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> lockExample.func());
executorService.execute(() -> lockExample.func());
}
```
关于 `Reentrant` 详细的使用案例 [参考此处](https://www.jianshu.com/p/155260c8af6c)
### 比较
> 1、锁的实现
synchronized 是 JVM 实现的，而 ReentrantLock 是 JDK 实现的。
> 2、性能
新版本 `Java` 对 `synchronized` 进行了很多优化，例如自旋锁等，synchronized 与 ReentrantLock 大致相同。
> 3、等待可终端
当持有锁的线程长期不释放锁的时候，正在等待的线程可以选择放弃等待，改为处理其他事情。
ReentrantLock 可中断，而 `synchronized` 不行。
> 4、公平锁
公平锁是指多个线程在等待同一个锁时，必须按照申请锁的时间顺序来依次获得锁。
而 `synchronized` 中的锁是非公平的，`ReentrantLock` 默认情况下也是非公平的，但是也可以是公平的（通过设置参数）。
> 5、锁绑定多个条件
一个 `ReentrantLock` 可以同时绑定多个 `Condition` 对象。
### 实际使用中该如何选择？
除非需要使用 `ReentrantLock` 的高级功能，否则优先使用 `synchronized`。
这是因为 synchronized 是 `JVM` 实现的一种锁机制，JVM 原生地支持它，而 ReentrantLock 不是所有的 `JDK` 版本都支持。并且使用 `synchronized` 不用担心没有释放锁而导致死锁问题，因为 JVM 会确保锁的释放。
## 0x06：线程状态
一个线程只能处于一种状态，并且这里的线程状态特指 `Java` 虚拟机的线程状态，不能反映线程在特定操作系统下的状态。
> 1、新建（NEW）
创建后尚未启动。
> 2、可运行（RUNABLE）
正在 Java 虚拟机中运行。但是在操作系统层面，它可能处于运行状态，也可能等待资源调度（例如处理器资源），等待资源调度完成后就进入运行状态。
所以该状态的可运行是指"可以被运行"，具体有没有运行要看底层操作系统的资源调度。
> 3、阻塞（BLOCKED）
请求获取 `monitor lock` 从而进入 `synchronized` 函数或者代码块，但是其它线程已经占用了该 `monitor lock`，所以处于阻塞状态。要结束该状态进入从而 RUNABLE 需要其他线程释放 monitor lock。
> 4、无限期等待（WAITING）
等待其它线程显式地唤醒。
阻塞和等待的区别在于，阻塞是被动的，它是在等待获取 `monitor lock`。而等待是主动的，通过调用 `Object.wait()` 等方法进入。
| 进入方法 | 退出方法 |
| ------------------------------------------ | ------------------------------------ |
| 没有设置 Timeout 参数的 Object.wait() 方法 | Object.notify() / Object.notifyAll() |
| 没有设置 Timeout 参数的 Thread.join() 方法 | 被调用的线程执行完毕 |
| LockSupport.park() 方法 | LockSupport.unpark(Thread) |
> 5、限期等待（TIMED_WAITING）
无需等待其它线程显式地唤醒，在一定时间之后会被系统自动唤醒。
| 进入方法 | 退出方法 |
| ---------------------------------------- | ----------------------------------------------- |
| Thread.sleep() 方法 | 时间结束 |
| 设置了 Timeout 参数的 Object.wait() 方法 | 时间结束 / Object.notify() / Object.notifyAll() |
| 设置了 Timeout 参数的 Thread.join() 方法 | 时间结束 / 被调用的线程执行完毕 |
| LockSupport.parkNanos() 方法 | LockSupport.unpark(Thread) |
| LockSupport.parkUntil() 方法 | LockSupport.unpark(Thread) |
调用 `Thread.sleep()` 方法使线程进入限期等待状态时，常常用 “使一个线程睡眠”进行描述。调用 `Object.wait()` 方法使线程进入限期等待或者无限期等待时，常常用“挂起一个线程”进行描述。
睡眠和挂起是用来描述"行为"，而阻塞和等待用来描述"状态"。
> 6、死亡（TERMINATED）
可以是线程结束任务之后自己结束，或者产生了异常而结束。
## 0x07：JUC&AQS
`java.util.concurrent`（J.U.C）大大提高了并发性能，`AQS` 被认为是 `J.U.C` 的核心。
### CountDownLatch
用来控制一个或者多个线程等待多个线程。
维护了一个计数器 `cnt`，每次调用 `countDown()` 方法会让计数器的值减 1，减到 0 的时候，那些因为调用 `await()` 方法而在等待的线程就会被唤醒。
如下图
```java
public class CountdownLatchExample {
public static void main(String[] args) throws InterruptedException {
final int totalThread = 10;
CountDownLatch countDownLatch = new CountDownLatch(totalThread);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < totalThread; i++) {
executorService.execute(() -> {
System.out.print("run..");
countDownLatch.countDown();
});
}
countDownLatch.await();
System.out.println("end");
executorService.shutdown();
}
}
```
运行结果
```html
run..run..run..run..run..run..run..run..run..run..end
```
### CyclicBarrier
用来控制多个线程互相等待，只有当多个线程都到达时，这些线程才会继续执行。
和 `CountdownLatch` 相似，都是通过维护计数器来实现的。线程执行 `await()` 方法之后计数器会减 `1`，并进行等待，直到计数器为 `0`，所有调用 `await()` 方法而在等待的线程才能继续执行。
CyclicBarrier 和 CountdownLatch 的一个区别是，`CyclicBarrier` 的计数器通过调用 `reset()` 方法可以循环使用，所以它才叫做循环屏障。
CyclicBarrier 有两个构造函数，其中 `parties` 指示计数器的初始值，`barrierAction` 在所有线程都到达屏障的时候会执行一次。如下代码
```java
public CyclicBarrier(int parties, Runnable barrierAction) {
if (parties <= 0) throw new IllegalArgumentException();
this.parties = parties;
this.count = parties;
this.barrierCommand = barrierAction;
}
public CyclicBarrier(int parties) {
this(parties, null);
}
```
如下图
测试代码
```java
public class CyclicBarrierExample {
public static void main(String[] args) {
final int totalThread = 10;
CyclicBarrier cyclicBarrier = new CyclicBarrier(totalThread);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < totalThread; i++) {
executorService.execute(() -> {
System.out.print("before..");
try {
cyclicBarrier.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
System.out.print("after..");
});
}
executorService.shutdown();
}
}
```
运行结果
```html
before..before..before..before..before..before..before..before..before..before..after..after..after..after..after..after..after..after..after..after..
```
### Semaphore
`Semaphore` 类似于操作系统中的信号量，可以控制对互斥资源的访问线程数。
以下代码模拟了对某个服务的并发请求，每次只能有 `3` 个客户端同时访问，请求总数为 `10`。
``` java
public class SemaphoreExample {
public static void main(String[] args) {
final int clientCount = 3;
final int totalRequestCount = 10;
Semaphore semaphore = new Semaphore(clientCount);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < totalRequestCount; i++) {
executorService.execute(()->{
try {
semaphore.acquire();
System.out.print(semaphore.availablePermits() + " ");
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
semaphore.release();
}
});
}
executorService.shutdown();
}
}
```
运行结果
```html
2 1 2 2 2 2 2 1 2 2
```
## 0x08：JUC&其他组件
### FutureTask
在介绍 `Callable` 时我们知道它可以有返回值，返回值通过 `Future` 进行封装。
FutureTask 实现了 RunnableFuture 接口，该接口继承自 `Runnable` 和 `Future` 接口，这使得 FutureTask 既可以当做一个任务执行，也可以有返回值。
如下代码
```java
public class FutureTask<V> implements RunnableFuture<V>
```
```java
public interface RunnableFuture<V> extends Runnable, Future<V>
```
FutureTask 可用于异步获取执行结果或取消执行任务的场景。当一个计算任务需要执行很长时间，那么就可以用 FutureTask 来封装这个任务，主线程在完成自己的任务之后再去获取结果。
如下代码
```java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @Author LCyee
* @Blog https://www.codeyee.com
* @Date 2020/9/27
* @Description 通过 FutureTask 获取线程的返回结果
*/
public class FutureTaskExample {
public static void main(String[] args) throws ExecutionException, InterruptedException {
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
int result = 0;
for (int i = 0; i < 100; i++) {
Thread.sleep(20);
result += i;
}
return result;
}
});
Thread computeThread = new Thread(futureTask);
computeThread.start();
Thread otherThread = new Thread(() -> {
System.out.println("other task is running...");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
otherThread.start();
//需要等待该线程执行结束后才能拿到返回结果
System.out.println(futureTask.get());
}
}
```
运行结果
```html
other task is running...
4950
```
### BlockingQueue
`java.util.concurrent.BlockingQueue` 接口有以下阻塞队列的实现：
- **FIFO 队列** ：LinkedBlockingQueue、ArrayBlockingQueue（固定长度）
- **优先级队列** ：PriorityBlockingQueue
提供了阻塞的 take() 和 put() 方法：如果队列为空 take() 将阻塞，直到队列中有内容；如果队列为满 put() 将阻塞，直到队列有空闲位置。
**使用 BlockingQueue 实现生产者消费者问题**
```java
public class ProducerConsumer {
private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(5);
private static class Producer extends Thread {
@Override
public void run() {
try {
queue.put("product");
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print("produce..");
}
}
private static class Consumer extends Thread {
@Override
public void run() {
try {
String product = queue.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.print("consume..");
}
}
}
```
```java
public static void main(String[] args) {
for (int i = 0; i < 2; i++) {
Producer producer = new Producer();
producer.start();
}
for (int i = 0; i < 5; i++) {
Consumer consumer = new Consumer();
consumer.start();
}
for (int i = 0; i < 3; i++) {
Producer producer = new Producer();
producer.start();
}
}
```
输出结果
```html
produce..produce..consume..consume..produce..consume..produce..consume..produce..consume..
```
### ForkJoin
主要用于并行计算中，和 `MapReduce` 原理类似，都是把大的计算任务拆分成多个小任务并行计算。如下图
> 关于MapReduce（摘自百度百科）：
>
> MapReduce是一种编程模型，用于大规模数据集（大于1TB）的并行运算。概念"Map（映射）"和"Reduce（归约）"，是它们的主要思想，都是从函数式编程语言里借来的，还有从矢量编程语言里借来的特性。它极大地方便了编程人员在不会分布式并行编程的情况下，将自己的程序运行在分布式系统上。 当前的软件实现是指定一个Map（映射）函数，用来把一组键值对映射成一组新的键值对，指定并发的Reduce（归约）函数，用来保证所有映射的键值对中的每一个共享相同的键组。
`ForkJoin` 的使用场景：
- 大数据量，需要通过并行执行任务，提高效率
如下代码所示
```java
public class ForkJoinDemo extends RecursiveTask<Long> {
private Long start; // 1
private Long end; // 1990900000
// 临界值
private Long temp = 10000L;
public ForkJoinDemo(Long start, Long end) {
this.start = start;
this.end = end;
}
// 计算方法
@Override
protected Long compute() {
if ((end-start)<temp){
Long sum = 0L;
for (Long i = start; i <= end; i++) {
sum += i;
}
return sum;
}else { // forkjoin 递归
long middle = (start + end) / 2; // 中间值
ForkJoinDemo task1 = new ForkJoinDemo(start, middle);
task1.fork(); // 拆分任务，把任务压入线程队列
ForkJoinDemo task2 = new ForkJoinDemo(middle+1, end);
task2.fork(); // 拆分任务，把任务压入线程队列
return task1.join() + task2.join();
}
}
}
```
`ForkJoin` 使用 `ForkJoinPool` 来启动，它是一个特殊的线程池，线程数量取决于 CPU 核数。并且实现了工作窃取算法来提高 `CPU` 的利用率。每个线程都维护了一个双端队列，用来存储需要执行的任务。
如下代码所示，我们来对比几种计算方式各自的效率
1、普通的计算方式
```java
// 正常的计算方式
public static void test1(){
Long sum = 0L;
long start = System.currentTimeMillis();
for (Long i = 1L; i <= 10_0000_0000; i++) {
sum += i;
}
long end = System.currentTimeMillis();
System.out.println("sum="+sum+" 时间："+(end-start));
}
```
2、使用 `ForkJoin` 进行计算，将大的计算任务进行拆分，并且可以根据我们的需求进行优化拆分计算的算法
```java
// 使用ForkJoin进行计算
public static void test2() throws ExecutionException, InterruptedException {
long start = System.currentTimeMillis();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask<Long> task = new ForkJoinDemo(0L, 10_0000_0000L);
ForkJoinTask<Long> submit = forkJoinPool.submit(task);// 提交任务
Long sum = submit.get();
long end = System.currentTimeMillis();
System.out.println("sum="+sum+" 时间："+(end-start));
}
```
对比两种计算方式的耗时
```java
public static void main(String[] args) throws ExecutionException, InterruptedException {
test1(); // 12224
test2(); // 10038
}
```
3、使用 `Stream` 并行流进行计算
```java
public static void test3(){
long start = System.currentTimeMillis();
// Stream并行流 () (]
long sum = LongStream.rangeClosed(0L, 10_0000_0000L).parallel().reduce(0, Long::sum);
long end = System.currentTimeMillis();
System.out.println("sum="+"时间："+(end-start));
}
```
再来对比着三种计算方式的效率
```java
public static void main(String[] args) throws ExecutionException, InterruptedException {
test1(); // 12224
test2(); // 10038
test3(); // 153
}
```
> 工作窃取算法：
工作窃取算法允许空闲的线程从其它线程的双端队列中窃取一个任务来执行。
窃取的任务必须是最晚的任务，避免和队列所属线程发生竞争。例如下图中，`Thread2` 从 `Thread1` 的队列中拿出最晚的 `Task1` 任务，`Thread1` 会拿出 `Task2` 来执行，这样就避免发生竞争。
但是如果队列中只有一个任务时还是会发生竞争。
## 0x09：线程不安全的示例
如果多个线程对同一个共享数据进行访问而不采取同步操作的话，那么操作的结果是不一致的。
以下代码演示了 `1000` 个线程同时对 `cnt` 执行自增操作，操作结束之后它的值有可能小于 `1000`。
```java
public class ThreadUnsafeExample {
private int cnt = 0;
public void add() {
cnt++;
}
public int get() {
return cnt;
}
}
```
```java
public static void main(String[] args) throws InterruptedException {
final int threadSize = 1000;
ThreadUnsafeExample example = new ThreadUnsafeExample();
final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < threadSize; i++) {
executorService.execute(() -> {
example.add();
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
System.out.println(example.get());
}
```
运行结果
```html
997
```
## 0x0A：Java内存模型
`Java` 内存模型试图屏蔽各种硬件和操作系统的内存访问差异，以实现让 `Java` 程序在各种平台下都能达到一致的内存访问效果。
### 主内存和工作内存
处理器上的寄存器的读写速度比内存快了几个量级，为了解决这种速度矛盾，在它们之间加入了高速缓存。
加入高速缓存带来了一个新的问题：缓存一致性。
如果多个缓存共享同一块主内存区域，那么多个缓存的数据可能会不一致，需要一些协议来解决这个问题。
所有的变量都存储在**主内存**中，每个线程还有自己的**工作内存**，工作内存存储在高速缓存或者寄存器中，保存了该线程使用的变量的主内存副本拷贝。
线程只能直接操作工作内存中的变量，不同线程之间的变量值传递需要通过**主内存**来完成。
### 内存间的交互操作
`Java` 内存模型定义了 `8` 个操作来完成主内存和工作内存的交互操作。
- **read：**
把一个变量的值从主内存传输到工作内存中
- **load：**
在 `read` 之后执行，把 `read` 得到的值放入工作内存的变量副本中
- **use：**
把工作内存中一个变量的值传递给执行引擎
- **assign：**
把一个从执行引擎接收到的值赋给工作内存的变量
- **store：**
把工作内存的一个变量的值传送到主内存中
- **write：**
在 `store` 之后执行，把 `store` 得到的值放入主内存的变量中
- **lock：**
作用于主内存的变量
- **unlock**
### 内存模型三大特性
#### 1、原子性
Java 内存模型保证了 `read`、`load`、`use`、`assign`、`store`、`write`、`lock` 和 `unlock` 操作具有原子性，例如对一个 `int` 类型的变量执行 `assign` 赋值操作，这个操作就是原子性的。
但是 `Java` 内存模型允许虚拟机将没有被 `volatile` 修饰的 `64` 位数据（long，double）的读写操作划分为两次 `32` 位的操作来进行，即 `load`、`store`、`read` 和 `write` 操作可以不具备原子性。
有一个错误认识就是，`int` 等原子性的类型在多线程环境中不会出现线程安全问题。在前面的线程不安全示例代码中，`cnt `变量属于 `int` 类型变量，`1000` 个线程对它进行自增操作之后，得到的值为 `997` 而不是 `1000`。
为了方便讨论，将内存间的交互操作简化为 3 个：`load`、`assign`、`store`。如下图
上图演示了两个线程同时对 `cnt` 进行操作，load、assign、store 这一系列操作整体上看不具备原子性，那么在 `T1` 修改 `cnt` 并且还没有将修改后的值写入主内存，`T2` 依然可以读入旧值。
可以看出，这两个线程虽然执行了两次自增运算，但是主内存中 `cnt` 的值最后为 `1` 而不是 `2`。因此对 `int` 类型读写操作满足原子性只是说明 load、assign、store 这些单个操作具备原子性。
**那么如何解决这个问题？**
使用 `AtomicInteger` 类型能保证多个线程修改的原子性。如下图所示
使用 `AtomicInteger` 重写之前线程不安全的代码之后得到以下线程安全实现：
```java
public class AtomicExample {
private AtomicInteger cnt = new AtomicInteger();
public void add() {
cnt.incrementAndGet();
}
public int get() {
return cnt.get();
}
}
```
```java
public static void main(String[] args) throws InterruptedException {
final int threadSize = 1000;
AtomicExample example = new AtomicExample(); // 只修改这条语句
final CountDownLatch countDownLatch = new CountDownLatch(threadSize);
ExecutorService executorService = Executors.newCachedThreadPool();
for (int i = 0; i < threadSize; i++) {
executorService.execute(() -> {
example.add();
countDownLatch.countDown();
});
}
countDownLatch.await();
executorService.shutdown();
System.out.println(example.get());
}
```
执行结果
```html
1000
```
#### 2、可见性
可见性指当一个线程修改了共享变量的值，其它线程能够立即得知这个修改。`Java` 内存模型是通过在变量修改后将"新值"同步回"主内存"，在变量读取前**从主内存刷新变量值**来实现"可见性"的。
主要有三种实现可见性的方式：
- 使用 `volatile` 关键字修饰变量
- 使用 `synchronized` 关键字，对一个变量执行 `unlock` 操作之前，必须把变量值同步回主内存。
- `final`，被 final 关键字修饰的字段在构造器中一旦初始化完成，并且没有发生 `this` 逃逸，那么其它线程就能看见 `final` 字段的值。
> this逃逸：其它线程通过 this 引用访问到初始化了一半的对象
对前面的线程不安全示例中的 `cnt` 变量使用 `volatile` 修饰，不能解决线程不安全问题，因为 `volatile` 并不能保证操作的原子性。
> 对一个 volatile 变量的写操作先行发生于后面对这个变量的读操作。
#### 3、有序性
有序性是指：在本线程内观察，所有操作都是有序的。在一个线程观察另一个线程，所有操作都是无序的，
无序是因为发生了 **指令重排序**。在 `Java` 内存模型中，允许编译器和处理器对指令进行重排序，重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。
`volatile` 关键字通过添加内存屏障的方式来禁止指令重排，即重排序时不能把后面的指令放到内存屏障之前。
也可以通过 `synchronized` 来保证有序性，它保证每个时刻只有一个线程执行同步代码，相当于是让线程顺序执行同步代码。
### 先行发生原则
上面提到了可以用 `volatile` 和 `synchronized` 来保证有序性。除此之外，`JVM` 还规定了先行发生原则，让一个操作无需控制就能先于另一个操作完成。
**1、单一线程原则**
在一个线程内，在程序前面的操作先行发生于后面的操作。如下图
**2、管程锁定规则**
一个 `unlock` 操作先行发生于后面对同一个锁的 `lock` 操作。
**3、volatile遍历规则**
对一个 `volatile` 变量的写操作先行发生于后面对这个变量的读操作。
**4、线程启动规则**
`Thread` 对象的 `start()` 方法调用先行发生于此线程的每一个动作。
**5、线程加入规则**
`Thread` 对象的结束先行发生于 `join()` 方法返回。
**6、线程中断规则**
对线程 `interrupt()` 方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过 `interrupted()` 方法检测到是否有中断发生。
> 通过调用一个线程的 interrupt() 来中断该线程，如果该线程处于阻塞、限期等待或者无限期等待状态，那么就会抛出 InterruptedException，从而提前结束该线程。但是不能中断 I/O 阻塞和 synchronized 锁阻塞。
**7、对象终结规则**
一个对象的初始化完成（构造函数执行结束）先行发生于它的 `finalize()` 方法的开始。
**8、传递性**
如果操作 `A` 先行发生于操作 `B`，操作 `B` 先行发生于操作 `C`，那么操作 A 先行发生于操作 C。
## 0x0B：线程安全
多个线程不管以何种方式访问某个类，并且在主调代码中不需要进行同步，都能表现正确的行为。线程安全有以下几种实现方式：
### 不可变
不可变（Immutable）的对象一定是线程安全的，不需要再采取任何的线程安全保障措施。只要一个不可变的对象被正确地构建出来，永远也不会看到它在多个线程之中处于不一致的状态。
多线程环境下，应当尽量使对象成为不可变，来满足线程安全。
不可变的类型：
- `final` 关键字修饰的基本数据类型
- `String`
- 枚举类型
- `Number` 部分子类，如 `Long` 和 `Double` 等数值包装类型，`BigInteger` 和 `BigDecimal` 等大数据类型。但同为 `Number` 的原子类 `AtomicInteger` 和 `AtomicLong` 则是可变的。
对于集合类型，可以使用 `Collections.unmodifiableXXX()` 方法来获取一个不可变的集合。如下代码所示
```java
public class ImmutableExample {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
Map<String, Integer> unmodifiableMap = Collections.unmodifiableMap(map);
unmodifiableMap.put("a", 1);
}
}
```
执行结果
```html
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.Collections$UnmodifiableMap.put(Collections.java:1457)
at ImmutableExample.main(ImmutableExample.java:9)
```
`Collections.unmodifiableXXX()` 先对原始的集合进行拷贝，需要对集合进行修改的方法都直接抛出异常。
```java
public V put(K key, V value) {
throw new UnsupportedOperationException();
}
```
### 互斥同步
使用 `synchronized` 和 `ReentrantLock`。
### 非阻塞同步
互斥同步最主要的问题就是**线程阻塞**和**唤醒**所带来的性能问题，因此这种同步也称为**阻塞同步**。
互斥同步属于一种悲观的并发策略（悲观锁），它总是认为只要不去做正确的同步措施，那就肯定会出现问题。无论共享数据是否真的会出现竞争，它都要进行加锁（这里讨论的是概念模型，实际上虚拟机会优化掉很大一部分不必要的加锁）、用户态核心态转换、维护锁计数器和检查是否有被阻塞的线程需要唤醒等操作。
随着硬件指令集的发展，我们可以使用基于冲突检测的乐观并发策略（乐观锁）：先进行操作，如果没有其它线程争用共享数据，那操作就成功了，否则采取补偿措施（不断地重试，直到成功为止）。
这种乐观的并发策略的许多实现都不需要将**线程阻塞**，因此这种同步操作称为**非阻塞同步**。
#### 1、CAS
乐观锁需要"操作"和"冲突检测"这两个步骤具备原子性，这里就不能再使用"互斥同步"来保证了，只能靠硬件来完成。硬件支持的原子性操作最典型的是：比较并交换（Compare-and-Swap，CAS）。`CAS` 指令需要有 `3` 个操作数，分别是内存地址 `V`、旧的预期值 `A` 和新值 `B`。当执行操作时，只有当 `V` 的值等于 `A`，才将 `V` 的值更新为 `B`。
#### 2、AtomicInteger
`J.U.C` 包里面的整数原子类 `AtomicInteger` 的方法调用了 `Unsafe` 类的 `CAS` 操作。
以下代码使用了 `AtomicInteger` 执行了自增的操作
```java
private AtomicInteger cnt = new AtomicInteger();
public void add() {
cnt.incrementAndGet();
}
```
以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 `getAndAddInt()` 。
```java
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
```
以下代码是 getAndAddInt() 源码，`var1` 指示对象内存地址，`var2` 指示该字段相对对象内存地址的偏移，`var4` 指示操作需要加的数值，这里为 `1`。通过 `getIntVolatile(var1, var2)` 得到旧的预期值，通过调用 `compareAndSwapInt()` 来进行 `CAS` 比较，如果该字段内存地址中的值等于 `var5`，那么就更新内存地址为 var1+var2 的变量为 var5+var4。
可以看到 `getAndAddInt()` 在一个循环中进行，发生冲突的做法是不断的进行重试。
```java
public final int getAndAddInt(Object var1, long var2, int var4) {
int var5;
do {
var5 = this.getIntVolatile(var1, var2);
} while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
return var5;
}
```
#### 3、ABA
如果一个变量初次读取的时候是 `A` 值，它的值被改成了 `B`，后来又被改回为 `A`，那 `CAS` 操作就会误认为它从来没有被改变过。
`J.U.C` 包提供了一个带有标记的原子引用类 `AtomicStampedReference` 来解决这个问题，它可以通过控制变量值的版本来保证 `CAS` 的正确性。大部分情况下 `ABA` 问题不会影响程序并发的正确性，如果需要解决 `ABA` 问题，改用传统的互斥同步可能会比原子类更高效。
### 无同步方案
#### 1、栈封闭
多个线程访问同一个方法的局部变量时，不会出现线程安全问题，因为局部变量存储在虚拟机栈中，属于线程私有的。
```java
public class StackClosedExample {
public void add100() {
int cnt = 0;
for (int i = 0; i < 100; i++) {
cnt++;
}
System.out.println(cnt);
}
}
```
```java
public static void main(String[] args) {
StackClosedExample example = new StackClosedExample();
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(() -> example.add100());
executorService.execute(() -> example.add100());
executorService.shutdown();
}
```
执行结果
```html
100
100
```
如果一段代码中所需要的数据必须与其他代码共享，那就看看这些共享数据的代码是否能保证在同一个线程中执行。如果能保证，我们就可以把"共享数据"的可见范围限制在同一个线程之内，这样，无须同步也能保证线程之间不出现数据争用的问题。
符合这种特点的应用并不少见，大部分使用消费队列的架构模式（如“生产者-消费者”模式）都会将产品的"消费过程"尽量在一个线程中消费完。其中最重要的一个应用实例就是经典 Web 交互模型中的“一个请求对应一个服务器线程”（Thread-per-Request）的处理方式，这种处理方式的广泛应用使得很多 `Web` 服务端应用都可以使用线程本地存储来解决线程安全问题。
可以使用 `java.lang.ThreadLocal` 类来实现线程本地存储功能。
对于以下代码，thread1 中设置 `threadLocal` 为 `1`，而 thread2 设置 `threadLocal` 为 `2`。过了一段时间之后，thread1 读取 threadLocal 依然是 1，不受 thread2 的影响。
```java
public class ThreadLocalExample {
public static void main(String[] args) {
ThreadLocal threadLocal = new ThreadLocal();
Thread thread1 = new Thread(() -> {
threadLocal.set(1);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadLocal.get());
threadLocal.remove();
});
Thread thread2 = new Thread(() -> {
threadLocal.set(2);
threadLocal.remove();
});
thread1.start();
thread2.start();
}
}
```
执行结果
```html
1
```
为了理解 `ThreadLocal`，先看以下代码：
```java
public class ThreadLocalExample1 {
public static void main(String[] args) {
ThreadLocal threadLocal1 = new ThreadLocal();
ThreadLocal threadLocal2 = new ThreadLocal();
Thread thread1 = new Thread(() -> {
threadLocal1.set(1);
threadLocal2.set(1);
});
Thread thread2 = new Thread(() -> {
threadLocal1.set(2);
threadLocal2.set(2);
});
thread1.start();
thread2.start();
}
}
```
它所对应的底层结构图为：
从上图可以看出 每个 Thread 都有一个 `ThreadLocal.ThreadLocalMap` 对象。
```java
/* ThreadLocal values pertaining to this thread. This map is maintained
* by the ThreadLocal class. */
ThreadLocal.ThreadLocalMap threadLocals = null;
```
当调用一个 `ThreadLocal` 的 `set(T value)` 方法时，先得到当前线程的 ThreadLocalMap 对象，然后将 ThreadLocal->value 键值对插入到该 `Map` 中。
```java
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
```
get() 方法也类似。
```java
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
```
`ThreadLocal` 从理论上讲并不是用来解决多线程并发问题的，因为根本不存在多线程竞争。
在一些场景 (尤其是使用线程池) 下，由于 `ThreadLocal.ThreadLocalMap` 的底层数据结构导致 `ThreadLocal` 有内存泄漏的情况，应该尽可能在每次使用 `ThreadLocal` 后手动调用 `remove()`，以避免出现 ThreadLocal 经典的内存泄漏甚至是造成自身业务混乱的风险。
#### 3、可重入代码（Reentrant Code）
这种代码也叫做纯代码（Pure Code），可以在代码执行的任何时刻中断它，转而去执行另外一段代码（包括递归调用它本身），而在控制权返回后，原来的程序不会出现任何错误。
可重入代码有一些共同的特征，例如不依赖存储在堆上的数据和公用的系统资源、用到的状态量都由参数中传入、不调用非可重入的方法等。
## 0x0C：锁的优化
这里的锁优化主要是指 `JVM` 对 `synchronized` 的优化。
### 自旋锁
互斥同步进入阻塞状态的开销都很大，应该尽量避免。在许多应用中，共享数据的锁定状态只会持续很短的一段时间。"自旋锁" 的思想是让一个线程在请求一个共享数据的锁时执行忙循环（自旋）一段时间，如果在这段时间内能获得锁，就可以避免进入阻塞状态。
自旋锁虽然能避免进入阻塞状态从而减少开销，但是它需要进行忙循环操作占用 CPU 时间，它只适用于共享数据的锁定状态很短的场景。
在 `JDK 1.6` 中引入了自适应的自旋锁。自适应意味着自旋的次数不再固定了，而是由前一次在同一个锁上的自旋次数及锁的拥有者的状态来决定。
### 锁消除
锁消除是指对于被检测出不可能存在竞争的共享数据的锁进行消除。
"锁消除"主要是通过逃逸分析来支持，如果堆上的共享数据不可能逃逸出去被其它线程访问到，那么就可以把它们当成私有数据对待，也就可以将它们的锁进行消除。
对于一些看起来没有加锁的代码，其实隐式的加了很多锁。例如下面的字符串拼接代码就隐式加了锁：
```java
public static String concatString(String s1, String s2, String s3) {
return s1 + s2 + s3;
}
```
`String` 是一个不可变的类，编译器会对 `String` 的拼接自动优化。在 JDK 1.5 之前，会转化为 `StringBuffer` 对象的连续 append() 操作，如下：
```java
public static String concatString(String s1, String s2, String s3) {
StringBuffer sb = new StringBuffer();
sb.append(s1);
sb.append(s2);
sb.append(s3);
return sb.toString();
}
```
每个 `append()` 方法中都有一个同步块。虚拟机观察变量 sb，很快就会发现它的动态作用域被限制在 `concatString()` 方法内部。也就是说，`sb` 的所有引用永远不会逃逸到 concatString() 方法之外，其他线程无法访问到它，因此可以进行消除。
### 锁粗化
如果一系列的连续操作都对同一个对象反复加锁和解锁，频繁的加锁操作就会导致性能损耗。
上一节的示例代码中连续的 `append()` 方法就属于这类情况。如果虚拟机探测到由这样的一串零碎的操作都对同一个对象加锁，将会把加锁的范围扩展（粗化）到整个操作序列的外部。对于上一节的示例代码就是扩展到第一个 append() 操作之前直至最后一个 append() 操作之后，**这样只需要加锁一次就可以了。**
### 轻量级锁
`JDK 1.6` 引入了偏向锁和轻量级锁，从而让锁拥有了四个状态：无锁状态（unlocked）、偏向锁状态（biasble）、轻量级锁状态（lightweight locked）和重量级锁状态（inflated）。
以下是 `HotSpot` 虚拟机对象头的内存布局，这些数据被称为 `Mark Word`。其中 `tag bits` 对应了五个状态，这些状态在右侧的 `state` 表格中给出。除了 `marked for gc` 状态，其它四个状态已经在前面介绍过了。
下图左侧是一个线程的虚拟机栈，其中有一部分称为 `Lock Record` 的区域，这是在轻量级锁运行过程创建的，用于存放锁对象的 `Mark Word`。而右侧就是一个锁对象，包含了 `Mark Word` 和其它信息。
**轻量级锁**是相对于传统的**重量级锁**而言，它使用 `CAS` 操作来避免重量级锁使用互斥量的开销。对于绝大部分的锁，在整个同步周期内都是不存在竞争的，因此也就不需要都使用互斥量进行同步，可以先采用 `CAS` 操作进行同步，如果 `CAS` 失败了再改用互斥量进行同步。
当尝试获取一个锁对象时，如果锁对象标记为 `0 01`，说明锁对象的锁未锁定（unlocked）状态。此时虚拟机在当前线程的虚拟机栈中创建 `Lock Record`，然后使用 `CAS` 操作将对象的 `Mark Word` 更新为 `Lock Record` 指针。如果 `CAS` 操作成功了，那么线程就获取了该对象上的锁，并且对象的 `Mark Word` 的锁标记变为 `00`，表示该对象处于轻量级锁状态。
### 偏向锁
偏向锁的思想是偏向于让第一个获取锁对象的线程，这个线程在之后获取该锁就不再需要进行同步操作，甚至连 `CAS` 操作也不再需要。
当锁对象第一次被线程获得的时候，进入偏向状态，标记为 `1 01`。同时使用 `CAS` 操作将线程 `ID` 记录到 `Mark Word` 中，如果 `CAS` 操作成功，这个线程以后每次进入这个锁相关的同步块就不需要再进行任何同步操作。
当有另外一个线程去尝试获取这个锁对象时，偏向状态就宣告结束，此时撤销偏向（Revoke Bias）后恢复到**未锁定状态**或者**轻量级锁状态**。
如下图所示
## 0x0D：多线程开发的良好实践
- 给线程起个有意义的名字，这样可以方便找 `Bug`。
- 缩小同步范围，从而减少锁争用。例如对于 `synchronized`，应该尽量使用同步块而不是同步方法。
- 多用同步工具少用 `wait()` 和 `notify()`。首先，CountDownLatch, CyclicBarrier, Semaphore 和 Exchanger 这些同步类简化了编码操作，而用 `wait(`) 和 `notify()` 很难实现复杂控制流；其次，这些同步类是由最好的企业编写和维护，在后续的 `JDK` 中还会不断优化和完善。
- 使用 `BlockingQueue` 实现生产者消费者问题。
- 多用并发集合少用同步集合，例如应该使用 `ConcurrentHashMap` 而不是 `Hashtable`。
- 使用本地变量和不可变类来保证线程安全。
- 使用线程池而不是直接创建线程，这是因为创建线程代价很高，线程池可以有效地利用有限的线程来启动任务。
# 参考资料
- [CyC2018 Notes](https://cyc2018.github.io/CS-Notes/#/notes/Java%20%E5%B9%B6%E5%8F%91)
- [JAVA高级&并发编程](https://codeyee.com/archives/java-thread.html)
- [【java基础-并发编程】daemon守护线程的作用](https://blog.csdn.net/u012121587/article/details/108331948)
- [【狂神说Java】JUC并发编程最新版通俗易懂](https://www.bilibili.com/video/BV1B7411L7tE)
浅谈JAVA并发机制
