1. 概述

1.1 这门课讲什么

这门课中的【并发】一次涵盖了在Java平台上的

• 进程
• 线程
• 并发
• 并行

以及Java并发工具、并发问题以及解决方案，同时我们也会讲解一些其它领域的并发。

1.2 为什么学这门课

• 我工作中用不到并发啊？

  1.3 课程特色

  本门课程以并发、并行为主线，穿插讲解

• 应用-结合实际

• 原理-了然于胸
• 模式-正确姿势

1.4 预备知识

• 希望你不是一个初学者
• 线程安全问题，需要你接触过Java Web开发、jdbc开发、Web服务器、分布式框架时才会遇到
• 基于JDK 8，最好对函数式编程、lambda有一定了解
• 采用slf4j打印日志，这是好的实践
• 给每个线程起名字，这也是一项好的实现

pom.xml依赖如下

<properties>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>
<dependencies>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.10</version>
    </dependency>
    <dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
</dependencies>

logback.xml配置如下

<?xml version="1.0" encoding="UTF-8"?>
<configuration
        xmlns="http://ch.qos.logback/xml/ns/logback"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://ch.qos.logback/xml/ns/logback logback.xsd">
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%date{HH:mm:ss} [%t] %logger - %m%n</pattern>
        </encoder>
    </appender>
    <logger name="c" level="debug" additivity="false">
        <appender-ref ref="STDOUT"/>
    </logger>
    <root level="ERROR">
        <appender-ref ref="STDOUT"/>
    </root>
</configuration>

2. 进程与线程

本章内容

• 进程和线程的概念
• 并行和并发的概念

• 线程基本应用

  2.1 进程与线程

  进程

• 程序由指令和数据组成，但这些指令要运行，数据要读写，就必须将指令加载至 CPU，数据加载至内存。在
  指令运行过程中还需要用到磁盘、网络等设备。进程就是用来加载指令、管理内存、管理 IO 的

• 当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。

• 进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程（例如记事本、画图、浏览器
  等），也有的程序只能启动一个实例进程（例如网易云音乐、360 安全卫士等）

  线程

• 一个进程之内可以分为一到多个线程。

• 一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
• Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。 在 windows 中进程是不活动的，只是作
  为线程的容器

进程负责加载指令到内存；线程负责执行指令
cpu从线程中获取指令

二者对比

• 进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
• 进程拥有共享的资源，如内存空间等，供其内部的线程共享
• 进程间通信较为复杂
  • 同一台计算机的进程通信称为 IPC（Inter-process communication）
  • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
• 线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

• 线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

  2.2 并行与并发

  单核 cpu 下，线程实际还是 串行执行 的。操作系统中有一个组件叫做任务调度器，将 cpu 的时间片（windows下时间片最小约为 15 毫秒）分给不同的程序使用，只是由于 cpu 在线程间（时间片很短）的切换非常快，人类感觉是 同时运行的 。总结为一句话就是： 微观串行，宏观并行 ，
  一般会将这种 线程轮流使用 CPU 的做法称为并发， concurrent
  
  
  多核 cpu下，每个 核（core） 都可以调度运行线程，这时候线程可以是并行的。
  
  
  引用 Rob Pike 的一段描述：

• 并发（concurrent）是同一时间应对（dealing with）多件事情的能力

• 并行（parallel）是同一时间动手做（doing）多件事情的能力

例子

• 家庭主妇做饭、打扫卫生、给孩子喂奶，她一个人轮流交替做这多件事，这时就是并发

• 家庭主妇雇了个保姆，她们一起这些事，这时既有并发，也有并行（这时会产生竞争，例如锅只有一口，一个人用锅时，另一个人就得等待）

  2.3 应用

  应用之异步调用(案例1)

  以调用方角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步

• 不需要等待结果返回，就能继续运行就是异步

  1) 设计

  多线程可以让方法执行变为异步的（即不要巴巴干等着）比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停…

  2) 结论

• 比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线程

• tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程(3.0支持的)

• ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

  应用之提高效率(案例1)

  充分利用多核 cpu 的优势，提高运行效率。想象下面的场景，执行 3 个计算，最后将计算结果汇总

  计算 1 花费 10 ms
  计算 2 花费 11 ms
  计算 3 花费 9 ms
  汇总需要 1 ms

• 如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms

• 但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3，那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms

  注意
  需要在多核 cpu 才能提高效率，单核仍然时是轮流执行

1) 设计

代码略！

2) 结论

1. 单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用cpu ，不至于一个线程总占用 cpu，别的线程没法干活
   2. 多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的

   • 有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任务都能拆分（参考后文的【阿姆达尔定律】）
   • 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义

2. IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】，这时相当于线程虽然不用 cpu，但需要一直等待 IO 结束，没能充分利用线程。所以才有后面的【非阻塞 IO】和【异步 IO】优化

   第三章 Java线程

   本章内容

• 创建和运行线程
• 查看线程
• 线程 API

• 线程状态

  3.1 创建和运行线程

  方法一，直接使用Thread

  // 创建线程对象
  Thread t = new Thread() {
    public void run() {
        // 要执行的任务
    }
  };
  // 启动线程
  t.start();

  例如：

  // 构造方法的参数是给线程指定名字，推荐
  Thread t1 = new Thread("t1") {
    @Override
    // run 方法内实现了要执行的任务
    public void run() {
        log.debug("hello");
    }
  };
  t1.start();

  输出

  19:19:00 [t1] c.ThreadStarter - hello

  方法二，使用Rrunnable配合Thread

  把【线程】和【任务】（要执行的代码）分开

• Thread 代表线程

• Runnable 可运行的任务（线程要执行的代码）

  Runnable runnable = new Runnable() {
    public void run(){
        // 要执行的任务
    }
  };
  // 创建线程对象
  Thread t = new Thread( runnable );
  // 启动线程
  t.start();

  例如：

  // 创建任务对象
  Runnable task2 = new Runnable() {
    @Override
    public void run() {
        log.debug("hello");
    }
  };
  // 参数1 是任务对象; 参数2 是线程名字，推荐
  Thread t2 = new Thread(task2, "t2");
  t2.start();

  输出

  19:19:00 [t2] c.ThreadStarter - hello

  Java 8 以后可以使用 lambda 精简代码 ```java // 创建任务对象 Runnable task2 = () -> log.debug(“hello”);

// 参数1 是任务对象; 参数2 是线程名字，推荐 Thread t2 = new Thread(task2, “t2”); t2.start();

<a name="PGvx9"></a>
### 原理之Thread与Runnable的关系
Thread继承自Runnable<br />怎么说呢？感觉不清不楚的：参考[https://www.cnblogs.com/soaringEveryday/p/4290725.html](https://www.cnblogs.com/soaringEveryday/p/4290725.html)<br />**0.**Thread继承自Runnable<br />**1.**使用上：Thread是继承，Runnable是实现，Java不允许多继承，因此Runnable更有优势。<br />**2.**关于共享数据问题：Runnable是可以共享数据的，多个Thread可以同时加载一个Runnable，当各自Thread获得CPU时间片的时候开始运行runnable，runnable里面的资源是被共享的
---
分析 Thread 的源码，理清它与 Runnable 的关系<br />**小结**
- 方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
- 用 Runnable 更容易与线程池等高级 API 配合
- 用 Runnable 让任务类脱离了 Thread 继承体系，更灵活
故此：更加推荐使用Runnable。
<a name="gFyvw"></a>
### 方法三，FutureTask配合Thread
FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况
```java
// 创建任务对象
// 使用 FutureTask 传入 Callable 接口方式创建
FutureTask<Integer> task3 = new FutureTask<>(() -> {
    log.debug("hello");
    return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
// 因为 FutureTask 这个类是实现了 RunnableFuture 接口，RunnableFuture 继承了 Runnable 接口
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get(); // get是阻塞式方法，会阻塞主线程等待结果返回
log.debug("结果是:{}", result);

输出：

19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100

其实是对runnable的扩展，可以获取执行结果,其间接实现了Runnable接口 其多实现了一个Future接口，这个接口有一个get方法返回任务执行结果的 Runnable接口定义的就是run方法，返回值是void 其要配合Callable接口使用 和runnable很像，只是有返回值，且可抛出异常

补充：
Future 就是对于具体的 Runnable 或者 Callable 任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过 get 方法获取执行结果，该方法会阻塞直到任务返回结果。

public interface Future<V> {
    // 取消任务
    boolean cancel(boolean mayInterruptIfRunning);
    // 获取任务执行结果
    V get() throws InterruptedException, ExecutionException;
    // 获取任务执行结果，带有超时时间限制
    V get(long timeout, TimeUnit unit) throws InterruptedException,                             ExecutionException,  TimeoutException;
    // 判断任务是否已经取消
    boolean isCancelled();
    // 判断任务是否已经结束
    boolean isDone();
}

FutureTask 类是 Future 接口和 Runable 接口的实现弥补 runnable 创建线程没有返回值的缺陷：了解更多见https://mp.weixin.qq.com/s/RX5rVuGr6Ab0SmKigmZEag

3.2 观察多个线程同时运行

主要是理解

• 交替执行

• 谁先谁后，不由我们控制

  3.3 查看进程线程的方法

  windows

• 任务管理器可以查看进程和线程数，也可以用来杀死进程

• tasklist 查看进程
• taskkill 杀死进程

linux

• ps -fe 查看所有进程
• ps -fT -p 查看某个进程（PID）的所有线程
• kill 杀死进程
• top 按大写 H 切换是否显示线程

• top -H -p 查看某个进程（PID）的所有线程

  Java

• jps 命令查看所有 Java 进程

• jstack 查看某个 Java 进程（PID）的所有线程状态

• jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

  3.4 原理之线程运行

  栈与栈帧

  Java Virtual Machine Stacks （Java 虚拟机栈）
  我们都知道 JVM 中由堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

• 每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存

• 每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

虚拟机栈描述的是Java方法执行的内存模型：
每个方法被执行的时候都会同时创建一个栈帧(stack frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息，是属于线程的私有的。
当java中使用多线程时，每个线程都会维护它自己的栈帧！每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法，当方法执行完会来到栈帧中的方法出口地址位置，然后从栈中 pop 出栈帧。

线程上下文切换(Thread Context Switch)

因为以下一些原因导致 cpu 不再执行当前的线程，转而执行另一个线程的代码
被动原因：

• 线程的 cpu 时间片用完(每个线程轮流执行，看前面并行的概念)
• 垃圾回收
• 有更高优先级的线程需要运行

主动原因：

• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念 就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的。

• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
• Context Switch 频繁发生会影响性能

因此：线程数越多越好吗？不是的，如果超过cpu核心数，就会频繁切换

3.5 常用方法

3.6 start 与 run

调用 run

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }
    };
    t1.run();
    log.debug("do other things ...");
}

结果

19:39:14 [main] c.TestStart - main
19:39:14 [main] c.FileReader - read [1.mp4] start ...
19:39:18 [main] c.FileReader - read [1.mp4] end ... cost: 4227 ms
19:39:18 [main] c.TestStart - do other things ...

程序仍在 main 线程运行， FileReader.read() 方法调用还是同步的

调用start

将上述代码的 t1.run() 改为

t1.start();

输出：

19:41:30 [main] c.TestStart - do other things ...
19:41:30 [t1] c.TestStart - t1
19:41:30 [t1] c.FileReader - read [1.mp4] start ...
19:41:35 [t1] c.FileReader - read [1.mp4] end ... cost: 4542 ms

程序在 t1 线程运行， FileReader.read() 方法调用是异步的

小结

• 直接调用 run 是在主线程中执行了 run，没有启动新的线程
• 使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

  3.7 sleep与yield

  sleep

1. 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
   2. 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException(所以sleep方法都要try)
   3. 睡眠结束后的线程未必会立刻得到执行
   4. 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性(底层就是Thread.sleep，只是其进行了单位换算)

   yield

2. 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程
   2. 具体的实现依赖于操作系统的任务调度器

   什么意思？你虽然让出去了，但是CPU会不会不执行你呢？不一定比如现在就一个线程，你让出去了，也还是执行你。

   两者区别：1虽然两者都是让出，但是对于后者，cpu还是可能会执行的，但是前者一定不会 2 前者有时间

线程优先级

• 线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
• 如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用

  Runnable task1 = () -> {
    int count = 0;
    for (;;) {
        System.out.println("---->1 " + count++);
    }
  };
  Runnable task2 = () -> {
    int count = 0;
    for (;;) {
        // Thread.yield();
        System.out.println(" ---->2 " + count++);
    }
  };
  Thread t1 = new Thread(task1, "t1");
  Thread t2 = new Thread(task2, "t2");
  // t1.setPriority(Thread.MIN_PRIORITY);
  // t2.setPriority(Thread.MAX_PRIORITY);
  t1.start();
  t2.start();

  和yield有点相似，如果线程少，你让了，也还是你的 虽然你优先级低，但是我cpu核数那么多，还是有你的

应用之效率(案例2)

防止CPU占用100% 不加sleep基本快100，加了之后，只有3%左右

3.8 join方法详解

为什么需要join

下面的代码执行，打印 r 是什么？

static int r = 0;
public static void main(String[] args) throws InterruptedException {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

分析

• 因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
• 而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法（想要得到r=10）

• 用 sleep 行不行？为什么？(可以，但是不太好，因为你不知道线程t1从开始到结束花费多长时间)

• 用 join，加在 t1.start() 之后即可（结果是看到了10，只是我不知道join是否实现了可见性？？）

  应用之同步(案例1)

  以调用方(主线程)角度来讲，如果

• 需要等待结果返回，才能继续运行就是同步

• 不需要等待结果返回，就能继续运行就是异步

等待多个结果

问，下面代码 cost 大约多少秒？

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test2();
}
private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r1 = 10;
    });
    Thread t2 = new Thread(() -> {
        sleep(2);
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

分析如下

• 第一个 join：等待 t1 时, t2 并没有停止, 而在运行

• 第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s
  如果颠倒两个 join 呢？（还是2s）
  最终都是输出

  20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005

  

  有时效的join

  等够时间

  static int r1 = 0;
  static int r2 = 0;
  public static void main(String[] args) throws InterruptedException {
    test3();
  }
  public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
  }

  输出

  20:48:01.320 [main] c.TestJoin - r1: 10 r2: 0 cost: 1010

  没等够时间

  static int r1 = 0;
  static int r2 = 0;
  public static void main(String[] args) throws InterruptedException {
    test3();
  }
  public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(2);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
  }

  输出

  20:52:15.623 [main] c.TestJoin - r1: 0 r2: 0 cost: 1502

  3.9 interrupt方法详解

  打断sleep，wait，join的线程

  三个方法都会导致阻塞状态；阻塞线程，任务调度器不会调度；这三个方法都会在被打断后，将打断标记清空。 join底层原理就是wait：

打断 sleep 的线程, 会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {
    Thread t1 = new Thread(()->{
        sleep(1);
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
    log.debug(" 打断状态: {}", t1.isInterrupted());
}

输出

java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at java.lang.Thread.sleep(Thread.java:340)
    at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
    at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
    at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
    at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false

注意：打断之后，这个程序是不会停的，它只是知道了有线程打断它

打断正常运行的线程

打断正常运行的线程, 不会清空打断状态

private static void test2() throws InterruptedException {
    Thread t2 = new Thread(()->{
        while(true) {
            Thread current = Thread.currentThread();
            boolean interrupted = current.isInterrupted();
            if(interrupted) { // 因此可以这么结束，即自己决定是继续执行，还是停止
                log.debug(" 打断状态: {}", interrupted);
                break;
            }
        }
    }, "t2");
    t2.start();
    sleep(0.5);
    t2.interrupt();
}

输出

20:57:37.964 [t2] c.TestInterrupt - 打断状态: true

打断之后，这个程序是不会停的，它只是知道了有线程打断它 interrput可以给线程一个机会，自己决定停还是不停，更优雅停的话还可以做一些事情 因此可以这么结束，即自己决定是继续执行，还是停止

模式之两阶段终止

打断park线程（LockSupport类的方法）

打断 park 线程, 不会清空打断状态

private static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        log.debug("park...");
        LockSupport.park();
        log.debug("unpark...");
        log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt(); // 如果没有这个打断，则park方法会阻塞到那里，是不会向下执行的
}

输出

21:11:52.795 [t1] c.TestInterrupt - park...
21:11:53.295 [t1] c.TestInterrupt - unpark...
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

如果打断标记已经是 true, 则 park 会失效

private static void test4() {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            log.debug("park...");
            LockSupport.park();
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }
    });
    t1.start();
    sleep(1);
    t1.interrupt();
}

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park...
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.812 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true

提示
可以使用 Thread.interrupted() 清除打断状态 至于更加详细的关于Park的方法的原理，后面有！

3.10 不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁

3.11 主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。
例：

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
    log.debug("开始运行...");
    sleep(2);
    log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

输出

08:26:38.123 [main] c.TestDaemon - 开始运行...
08:26:38.213 [daemon] c.TestDaemon - 开始运行...
08:26:39.215 [main] c.TestDaemon - 运行结束...

注意

• 垃圾回收器线程就是一种守护线程
• Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

3.12 五种状态（对于线程状态：网上有说五种，有说六种，我们这里解释清楚）

这是从 操作系统 层面来描述的

• 【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
• 【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
• 【运行状态】指获取了 CPU 时间片运行中的状态
  • 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
• 【阻塞状态】
  • 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
  • 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
  • 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
• 【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

  调度器是不会分配时间片给阻塞状态的 只会给可运行状态 阻塞状态什么时候恢复呢？当IO操作完毕了 操作系统会将这个线程从阻塞状态唤醒，到可运行状态 至于什么时候被执行，还要看调度器给你分配时间片

3.13 六种状态

这是从 Java API 层面来描述的
根据 Thread.State 枚举，分为六种状态

• NEW 线程刚被创建，但是还没有调用 start() 方法
• RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了 操作系统 层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
• BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述

• TERMINATED 当线程代码运行结束

  3.14 习题

  阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方案，提示

• 参考图二，用两个线程（两个人协作）模拟烧水泡茶过程

  • 文中办法乙、丙都相当于任务串行
  • 而图一相当于启动了 4 个线程，有点浪费
• 用 sleep(n) 模拟洗茶壶、洗水壶等耗费的时间

附：华罗庚《统筹方法》

统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复
杂的科研项目的组织与管理中，都可以应用。
怎样应用呢？主要是把工序安排好。 比如，想泡壶茶喝。当时的情况是：开水没有；水壶要洗，茶壶、茶杯要洗；火已生了，茶叶也有了。怎么
办？
办法甲：洗好水壶，灌上凉水，放在火上；在等待水开的时间里，洗茶壶、洗茶杯、拿茶叶；等水开了，泡茶喝。
办法乙：先做好一些准备工作，洗水壶，洗茶壶茶杯，拿茶叶；一切就绪，灌水烧水；坐待水开了，泡茶喝。
办法丙：洗净水壶，灌上凉水，放在火上，坐待水开；水开了之后，急急忙忙找茶叶，洗茶壶茶杯，泡茶喝。
哪一种办法省时间？我们能一眼看出，第一种办法好，后两种办法都窝了工。
这是小事，但这是引子，可以引出生产管理等方面有用的方法来。
水壶不洗，不能烧开水，因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯，就不能泡茶，因而
这些又是泡茶的前提。它们的相互关系，可以用下边的箭头图来表示：
从这个图上可以一眼看出，办法甲总共要16分钟（而办法乙、丙需要20分钟）。如果要缩短工时、提高工作
效率，应当主要抓烧开水这个环节，而不是抓拿茶叶等环节。同时，洗茶壶茶杯、拿茶叶总共不过4分钟，大
可利用“等水开”的时间来做。
是的，这好像是废话，卑之无甚高论。有如走路要用两条腿走，吃饭要一口一口吃，这些道理谁都懂得。但
稍有变化，临事而迷的情况，常常是存在的。在近代工业的错综复杂的工艺过程中，往往就不是像泡茶喝这
么简单了。任务多了，几百几千，甚至有好几万个任务。关系多了，错综复杂，千头万绪，往往出现“万事俱
备，只欠东风”的情况。由于一两个零件没完成，耽误了一台复杂机器的出厂时间。或往往因为抓的不是关
键，连夜三班，急急忙忙，完成这一环节之后，还得等待旁的环节才能装配。
洗茶壶，洗茶杯，拿茶叶，或先或后，关系不大，而且同是一个人的活儿，因而可以合并成为：
看来这是“小题大做”，但在工作环节太多的时候，这样做就非常必要了。
这里讲的主要是时间方面的事，但在具体生产实践中，还有其他方面的许多事。这种方法虽然不一定能直接
解决所有问题，但是，我们利用这种方法来考虑问题，也是不无裨益的。

应用之统筹(烧水泡茶)

本章小结

本章的重点在于掌握

• 线程创建
• 线程重要 api，如 start，run，sleep，join，interrupt 等
• 线程状态
• 应用方面
  • 异步调用：主线程执行期间，其它线程异步执行耗时操作
  • 提高效率：并行计算，缩短运算时间
  • 同步等待：join
  • 统筹规划：合理使用线程，得到最优效果
• 原理方面
  • 线程运行流程：栈、栈帧、上下文切换、程序计数器
  • Thread 两种创建方式 的源码
• 模式方面
  • 终止模式之两阶段终止

    第四章 共享模型之管程

    本章内容

    共享问题
    synchronized
    线程安全分析
    Monitor
    wait/notify
    线程状态转换
    活跃性
    Lock

4.1 共享带来的问题

小故事

老王（操作系统）有一个功能强大的算盘（CPU），现在想把它租出去，赚一点外快

• 小南、小女（线程）来使用这个算盘来进行一些计算，并按照时间给老王支付费用
• 但小南不能一天24小时使用算盘，他经常要小憩一会（sleep），又或是去吃饭上厕所（阻塞 io 操作），有时还需要一根烟，没烟时思路全无（wait）这些情况统称为（阻塞）

• 在这些时候，算盘没利用起来（不能收钱了），老王觉得有点不划算
• 另外，小女也想用用算盘，如果总是小南占着算盘，让小女觉得不公平
• 于是，老王灵机一动，想了个办法 [ 让他们每人用一会，轮流使用算盘 ]
• 这样，当小南阻塞的时候，算盘可以分给小女使用，不会浪费，反之亦然
• 最近执行的计算比较复杂，需要存储一些中间结果，而学生们的脑容量（工作内存）不够，所以老王申请了
  一个笔记本（主存），把一些中间结果先记在本上
• 计算流程是这样的

• 但是由于分时系统，有一天还是发生了事故
• 小南刚读取了初始值 0 做了个 +1 运算，还没来得及写回结果
• 老王说 [ 小南，你的时间到了，该别人了，记住结果走吧 ]，于是小南念叨着 [ 结果是1，结果是1…] 不甘心地
  到一边待着去了（上下文切换）
• 老王说 [ 小女，该你了 ]，小女看到了笔记本上还写着 0 做了一个 -1 运算，将结果 -1 写入笔记本
• 这时小女的时间也用完了，老王又叫醒了小南：[小南，把你上次的题目算完吧]，小南将他脑海中的结果 1 写
  入了笔记本

• 小南和小女都觉得自己没做错，但笔记本里的结果是 1 而不是 0

  Java的体现

  两个线程对初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果是 0 吗？ ```java static int counter = 0;

public static void main(String[] args) throws InterruptedException { Thread t1 = new Thread(() -> { for (int i = 0; i < 5000; i++) { counter++; } }, “t1”);

Thread t2 = new Thread(() -> {
    for (int i = 0; i < 5000; i++) {
        counter--;
    }
}, "t2");
t1.start();
t2.start();
t1.join();
t2.join();
log.debug("{}",counter);

}

<a name="RA9Qx"></a>
### 问题分析
以上的结果可能是正数、负数、零。为什么呢？因为 Java 中对静态变量的自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析<br />例如对于 i++ 而言（i 为静态变量），实际会产生如下的 JVM 字节码指令：
```java
getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
iadd // 自增
putstatic i // 将修改后的值存入静态变量i

而对应 i— 也是类似

getstatic i // 获取静态变量i的值
iconst_1 // 准备常量1
isub // 自减
putstatic i // 将修改后的值存入静态变量i

而 Java 的内存模型如下，完成静态变量的自增，自减需要在主存和工作内存中进行数据交换：

如果是单线程以上 8 行代码是顺序执行（不会交错）没有问题：

但多线程下这 8 行代码可能交错运行：
出现负数的情况：

出现正数的情况：

临界区Critical Section

• 一个程序运行多个线程本身是没有问题的
• 问题出在多个线程访问共享资源
  • 多个线程读共享资源其实也没有问题
  • 在多个线程对共享资源读写操作时发生指令交错，就会出现问题
• 一段代码块内如果存在对共享资源的多线程读写操作，称这段代码块为临界区

例如，下面代码中的临界区

static int counter = 0;
static void increment()
// 临界区
{
    counter++;
}
static void decrement()
// 临界区
{
    counter--;
}

竞态条件 Race Condition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件
这句话看似普通，其实很关键！
重点1：多个线程
重点2：临界区

4.2 Synchronized解决方案

应用之互斥

为了避免临界区的竞态条件发生，有多种手段可以达到目的。

• 阻塞式的解决方案：synchronized，Lock
• 非阻塞式的解决方案：原子变量

本次课使用阻塞式的解决方案：synchronized，来解决上述问题，即俗称的【对象锁】，它采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。这样就能保证拥有锁的线程可以安全的执行临界区内的代码，不用担心线程上下文切换

注意
虽然 java 中互斥和同步都可以采用 synchronized 关键字来完成，但它们还是有区别的：

• 互斥是保证临界区的竞态条件发生，同一时刻只能有一个线程执行临界区代码
• 同步是由于线程执行的先后、顺序不同、需要一个线程等待其它线程运行到某个点

synchronized

语法

synchronized(对象) // 线程1， 线程2(blocked)
{
    临界区
}

解决

static int counter = 0;
static final Object room = new Object();
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            synchronized (room) {
                counter++;
            }
        }
    }, "t1");
    Thread t2 = new Thread(() -> {
        for (int i = 0; i < 5000; i++) {
            synchronized (room) {
                counter--;
            }
        }
    }, "t2");
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    log.debug("{}",counter);
}

你可以做这样的类比：

• synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门）房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人
• 当线程 t1 执行到 synchronized(room) 时就好比 t1 进入了这个房间，并锁住了门拿走了钥匙，在门内执行count++ 代码
• 这时候如果 t2 也运行到了 synchronized(room) 时，它发现门被锁住了，只能在门外等待，发生了上下文切换，阻塞住了
• 这中间即使 t1 的 cpu 时间片不幸用完，被踢出了门外（不要错误理解为锁住了对象就能一直执行下去哦），这时门还是锁住的，t1 仍拿着钥匙，t2 线程还在阻塞状态进不来，只有下次轮到 t1 自己再次获得时间片时才能开门进入(用这个理还是很有意思的)
• 当 t1 执行完 synchronized{} 块内的代码，这时候才会从 obj 房间出来并解开门上的锁，唤醒 t2 线程把钥匙给他。t2 线程这时才可以进入 obj 房间，锁住了门拿上钥匙，执行它的 count— 代码

用图来表示

思考

synchronized 实际是用对象锁保证了临界区内代码的原子性，临界区内的代码对外是不可分割的，不会被线程切换所打断。
为了加深理解，请思考下面的问题

• 如果把 synchronized(obj) 放在 for 循环的外面，如何理解？— 原子性
• 如果 t1 synchronized(obj1) 而 t2 synchronized(obj2) 会怎样运作？— 锁对象
• 如果 t1 synchronized(obj) 而 t2 没有加会怎么样？如何理解？— 锁对象

其实理解上面的内容很简单：几个所就是几个房间，上的临界区是两个。如想真正锁住，其实只需要一个房间，放下所有临界区代码即可。

面向对象改进

把需要保护的共享变量放入一个类

class Room {
    int value = 0;
    public void increment() {
        synchronized (this) {
            value++;
        }
    }
    public void decrement() {
        synchronized (this) {
            value--;
        }
    }
    // 实话说，这个算不算临界区，不知道意义何在
    public int get() {
        synchronized (this) {
            return value;
        }
    }
}
@Slf4j
public class Test1 {
    public static void main(String[] args) throws InterruptedException {
        Room room = new Room(); // 资源
        Thread t1 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                room.increment();
            }
        }, "t1");
        Thread t2 = new Thread(() -> {
            for (int j = 0; j < 5000; j++) {
                room.decrement();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.debug("count: {}" , room.get());
    }
}

4.3 方法上的synchronized

class Test{
    public synchronized void test() {
    }
}
等价于
class Test{
    public void test() {
        synchronized(this) {
        }
    }
}

class Test{
    public synchronized static void test() {
    }
}
等价于
class Test{
    public static void test() {
        synchronized(Test.class) {
        }
    }
}

不加synchronized的方法

不加 synchronzied 的方法就好比不遵守规则的人，不去老实排队（好比翻窗户进去的）

所谓的”线程八锁”

其实就是考察 synchronized 锁住的是哪个对象
情况1：12 或 21

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

情况2：1s后12，或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

情况3：3 1s 12 或 23 1s 1 或 32 1s 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
    public void c() {
        log.debug("3");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
    new Thread(()->{ n1.c(); }).start();
}

情况4：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

情况5：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

情况6：1s 后12， 或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
        public static synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n1.b(); }).start();
}

情况7：2 1s 后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

情况8：1s 后12， 或 2 1s后 1

@Slf4j(topic = "c.Number")
class Number{
    public static synchronized void a() {
        sleep(1);
        log.debug("1");
    }
    public static synchronized void b() {
        log.debug("2");
    }
}
public static void main(String[] args) {
    Number n1 = new Number();
    Number n2 = new Number();
    new Thread(()->{ n1.a(); }).start();
    new Thread(()->{ n2.b(); }).start();
}

4.4 变量的线程安全分析

成员变量和静态变量是否线程安全？

• 如果它们没有共享，则线程安全

• 如果它们被共享了，根据它们的状态是否能够改变，又分两种情况

  • 如果只有读操作，则线程安全
  • 如果有读写操作，则这段代码是临界区，需要考虑线程安全

    局部变量是否线程安全？

• 局部变量是线程安全的

• 但局部变量引用的对象则未必

  • 如果该对象没有逃离方法的作用访问，它是线程安全的

  • 如果该对象逃离方法的作用范围，需要考虑线程安全

    局部变量线程安全分析

    public static void test1() {
    int i = 10;
    i++;
    }

    每个线程调用 test1() 方法时局部变量 i，会在每个线程的栈帧内存中被创建多份，因此不存在共享

    public static void test1();
    descriptor: ()V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
       stack=1, locals=1, args_size=0
           0: bipush 10
           2: istore_0
           3: iinc 0, 1
           6: return
       LineNumberTable:
           line 10: 0
           line 11: 3
           line 12: 6
       LocalVariableTable:
           Start Length Slot Name Signature
               3 4 0 i I

    如图
    
    局部变量的引用稍有不同
    先看一个成员变量的例子

    class ThreadUnsafe {
    ArrayList<String> list = new ArrayList<>();
    public void method1(int loopNumber) {
       for (int i = 0; i < loopNumber; i++) {
           // { 临界区, 会产生竞态条件
           method2();
           method3();
           // } 临界区
       }
    }
    private void method2() {
       list.add("1");
    }
    private void method3() {
       list.remove(0);
    }
    }

    执行

    static final int THREAD_NUMBER = 2;
    static final int LOOP_NUMBER = 200;
    public static void main(String[] args) {
    ThreadUnsafe test = new ThreadUnsafe();
    for (int i = 0; i < THREAD_NUMBER; i++) {
       new Thread(() -> {
           test.method1(LOOP_NUMBER);
       }, "Thread" + i).start();
    }
    }

    其中一种情况是，如果线程2 还未 add，线程1 remove 就会报错：

    Exception in thread "Thread1" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
    at java.util.ArrayList.rangeCheck(ArrayList.java:657)
    at java.util.ArrayList.remove(ArrayList.java:496)
    at cn.itcast.n6.ThreadUnsafe.method3(TestThreadSafe.java:35)
    at cn.itcast.n6.ThreadUnsafe.method1(TestThreadSafe.java:26)
    at cn.itcast.n6.TestThreadSafe.lambda$main$0(TestThreadSafe.java:14)
    at java.lang.Thread.run(Thread.java:748)

    分析：

• 无论哪个线程中的 method2 引用的都是同一个对象中的 list 成员变量

• method3 与 method2 分析相同

将list修改为局部变量

class ThreadSafe {
    public final void method1(int loopNumber) {
        ArrayList<String> list = new ArrayList<>();
        for (int i = 0; i < loopNumber; i++) {
            method2(list);
            method3(list);
        }
    }
    private void method2(ArrayList<String> list) {
        list.add("1");
    }
    private void method3(ArrayList<String> list) {
        list.remove(0);
    }
}

那么就不会有上述问题了
分析：

• list 是局部变量，每个线程调用时会创建其不同实例，没有共享
• 而 method2 的参数是从 method1 中传递过来的，与 method1 中引用同一个对象
• method3 的参数分析与 method2 相同

方法访问修饰符带来的思考，如果把 method2 和 method3 的方法修改为 public 会不会代理线程安全问题？

• 情况1：有其它线程调用 method2 和 method3

• 情况2：在 情况1 的基础上，为 ThreadSafe 类添加子类，子类覆盖 method2 或 method3 方法，即 ```java class ThreadSafe { public final void method1(int loopNumber) {

    ArrayList<String> list = new ArrayList<>();
    for (int i = 0; i < loopNumber; i++) {
        method2(list);
        method3(list);
    }

  }

  private void method2(ArrayList list) {

    list.add("1");

  } private void method3(ArrayList list) {

    list.remove(0);

  } }

class ThreadSafeSubClass extends ThreadSafe{ @Override public void method3(ArrayList list) { new Thread(() -> { list.remove(0); }).start(); } }

> 子类是无法控制的，里面又创建了线程，就不安全了
> 因此我觉得应该设置为private，这样子类就不能重写了
> 因此private可以保证线程安全(子类无法继重写)
> 或者对于public，可以用final
> **从这个例子可以看出 private 或 final 提供【安全】的意义所在，请体会开闭原则中的【闭】**
<a name="vx5TX"></a>
### 常见线程安全类
- String
- Integer
- StringBuffer
- Random
- Vector
- Hashtable
- java.util.concurrent 包下的类<br />这里说它们是线程安全的是**指**，**多个线程调用它们同一个实例的某个方法时，是线程安全的**。也可以理解为
```java
Hashtable table = new Hashtable();
new Thread(()->{
    table.put("key", "value1");
}).start();
new Thread(()->{
    table.put("key", "value2");
}).start();

• 它们的每个方法是原子的

• 但注意它们多个方法的组合不是原子的，见后面分析

  线程安全类方法的组合

  分析下面代码是否线程安全？

  Hashtable table = new Hashtable();
  // 线程1，线程2
  if( table.get("key") == null) {
    table.put("key", value); // 本来想为空时，只放一个值，但是下面代码放了两个
  }

  

  不可变类线程安全性

  String、Integer 等都是不可变类，因为其内部的状态不可以改变，因此它们的方法都是线程安全的（内部只能读，不能改）
  有同学或许有疑问，String 有 replace，substring 等方法【可以】改变值啊，那么这些方法又是如何保证线程安全的呢？（因为没改变原有的，是创建的新的，复制的值）

  public class Immutable{
    private int value = 0;
    public Immutable(int value){
        this.value = value;
    }
    public int getValue(){
        return this.value;
    }
  }

  如果想增加一个增加的方法呢？

  public class Immutable{
    private int value = 0;
    public Immutable(int value){
        this.value = value;
    }
    public int getValue(){
        return this.value;
    }
    public Immutable add(int v){
        return new Immutable(this.value + v);
    }
  }

  实例分析

  例1：

  public class MyServlet extends HttpServlet {
  // 是否安全？
    Map<String,Object> map = new HashMap<>();
    // 是否安全？
    String S1 = "...";
    // 是否安全？
    final String S2 = "...";
    // 是否安全？
    Date D1 = new Date();
    // 是否安全？
    final Date D2 = new Date();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        // 使用上述变量
    }
  }

  例2： ```java public class MyServlet extends HttpServlet { // 是否安全？ private UserService userService = new UserServiceImpl();

  public void doGet(HttpServletRequest request, HttpServletResponse response) {

    userService.update(...);

  } }

public class UserServiceImpl implements UserService { // 记录调用次数 private int count = 0;

public void update() {
    // ...
    count++;
}

}

例3：
```java
@Aspect
@Component
public class MyAspect {
    // 是否安全？
    private long start = 0L;
    @Before("execution(* *(..))")
    public void before() {
        start = System.nanoTime();
    }
    @After("execution(* *(..))")
    public void after() {
        long end = System.nanoTime();
        System.out.println("cost time:" + (end-start));
    }
}

例4

public class MyServlet extends HttpServlet {
    // 是否安全
    private UserService userService = new UserServiceImpl();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全
    private UserDao userDao = new UserDaoImpl();
    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    public void update() {
        String sql = "update user set password = ? where username = ?";
        // 是否安全
        try (Connection conn = DriverManager.getConnection("","","")){
            // ...
        } catch (Exception e) {
            // ...
        }
    }
}

例5

public class MyServlet extends HttpServlet {
    // 是否安全
    private UserService userService = new UserServiceImpl();
    public void doGet(HttpServletRequest request, HttpServletResponse response) {
        userService.update(...);
    }
}
public class UserServiceImpl implements UserService {
    // 是否安全
    private UserDao userDao = new UserDaoImpl();
    public void update() {
        userDao.update();
    }
}
public class UserDaoImpl implements UserDao {
    // 是否安全
    private Connection conn = null;
    public void update() throws SQLException {
        String sql = "update user set password = ? where username = ?";
        conn = DriverManager.getConnection("","","");
        // ...
        conn.close();
    }
}