预备知识

希望你不是一个初学者

线程安全问题，需要你接触过 Java Web 开发、Jdbc 开发、Web 服务器、分布式框架时才会遇到

基于 JDK 8，最好对函数式编程、lambda 有一定了解

采用了 slf4j 打印日志，这是好的实践

采用了 lombok 简化 java bean 编写

给每个线程好名字，这是有必要的

进程与线程

进程

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

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

进程就可以视为程序的一个实例，大部分程序可以同时运行多个实例（列如 记事本，画图），也有的程序只能启动一个实例进程（网易云音乐）

线程

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

一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给CPU执行。

Java中，线程作为最小调度单位，进程作为资源分配的最小单位，在windows中进程是不活动的，只是作为线程的容器。

对比

• 进程基本上是相互独立的，而线程存于进程内，是进程的一个子集

• 进程拥有共享的资源，如内存空间等，供其内部的线程共享

• 进程的通信比较复杂

  • 同一台计算机的进程通信称之为IPC（Inter process communication）
  • 不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，列入HTTP

• 线程通信相对简单，因为他们共享进程内的内存，一个列子是多个线程可以访问同一个共享变量

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

并行与并发

单核 CPU 下，线程实际上还是串行执行的，操作系统中有一个叫任务调度器，将 CPU 的时间片（windows下时间最小为15毫秒）分给不同的线程使用，只是由于 CPU 在线程间 （时间很短） 的切换非常快，人类感觉是同时运行的，总结一句话是微观是串行，宏观是并行

一般会将这种线程轮流使用 CPU 的做法叫做并发 concurrent

多核 cpu 下 每个核心 core 都可以调度运行线程，这时候线程是可以并行的

引用 Rob Pike 的一段描述:

并发 (current) 是同一时间应对 (dealing with) 多件事情的能力

并行 (parallel) 是同一时间动手做 (doing) 多件事情的能力

同步与异步

以调用方角度来讲，如果

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

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

多线程可以让方法执行变为异步的（即不要巴巴干等着）

比如说读取磁盘文件时，假设读取操作花费了 5 秒钟，如果没有线程调度机制，这 5 秒 cpu 什么都做不了，其它代码都得暂停…

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

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

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

充分利用多核 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. 单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换，不同线程轮流使用 cpu ，不至于一个线程总占用 cpu，别的线程没法干活。

2. 多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的，有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任务都能拆分（参考后文的【阿姆达尔定律】）

3. 也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义

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

查看进程线程

Windows

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

tasklist 查看进程

taskkill杀死进程

Linux

ps -fe 查看所有线程

ps -fT -p <PID> 查看某个进程 (PID) 的所有线程

kill 杀死线程

top 大写H切换是否线程线程

top -H -p <PID> 查看某个进程 (PID) 的所有线程

Java

jps 查看所有Java线程

jstack <PID>查看某个Java进程 (PID) 的所有线程状态

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

jconsole 也可以用来远程监控，需要在远程机配置

java -Djava.rmi.server.hostname=`ip地址` -Dcom.sun.management.jmxremote -
Dcom.sun.management.jmxremote.port=`连接端口` -Dcom.sun.management.jmxremote.ssl=`是否安全连接|fales\true` -
Dcom.sun.management.jmxremote.authenticate=`fales\true`

Java线程

使用Thread

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

Lambda（推荐）

new Thread(() -> {
    log.debug("--running");
}, "your thread name").start();

使用Runnable

需要搭配 Thread 一起食用

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

Thread 代表线程

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

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

同理可以使用 Lambda

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

Thread与Runnable

上面提到的方法1：是把线程和任务合并在了一起，方法2：是把线程和任务分开了

用 Runnable 更容易与线程池等高级 API 配合

用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

Runnable.run() 方法归根结底就是传到了 Thread.run() 中。

使用FutureTask

同样需要配合 Thread，FutureTask 接收 Callable 类型的参数，用来处理有返回结果的情况

// 创建任务对象
FutureTask<Integer> task3 = new FutureTask<>(() -> {
  log.debug("hello");
  return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result)

线程运行原理

栈与栈帧

Java Virtual Machine Stacks (Java虚拟机中栈)

我们都知道JVM由堆、栈、方法区组成，其中栈内存是给谁用的，其实就是线程，每个线程启动后，虚拟机就会为它分配一块栈内存

• 每个栈由多个 栈帧(Frame) 组成，对应着每次方法调用时所占用的内存
• 每个线程只能有一次活动栈帧，对应着当前正在执行的那个方法

在下图中，我们看到 main 线程栈中，最终拥有3个栈帧，原因是一共调用到了3个方法，分别是 main 方法，method1，method2，当 method2 活动结束后就会被回收，也就是最后代码执行完栈帧会为空。

IDEA 打断点时，选择 Thread ，可以看到两个线程的栈内存是相互独立的，互不干扰。

线程上下文切换

因为一些原因导致 cpu 不再执行当前线程，转而执行另一个线程的代码，就会发生线程上下文切换（Thread Context Switch）

• 线程的 cpu 时间片用完
• 垃圾回收
• 有更高优先级线程需要运行
• 线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

当 Context Switch 发生时，需要由操作系统，保持当前线程状态，并恢复另一个线程的状态， Java 中对应的概念就是程序计数器（Program Counter Register），他的作用时记住下一条 jvm 指令的执行地址， 是线程私有的，状态包括程序计数器 虚拟机栈中每个栈帧的信息，如局部变量，操作数栈，返回地址等。

注意：Context Switch 频繁发生会影响性能

常用方法

run 与 start

直接调用 run 是在主线程中执行了 run，没有启动新的线程

使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

sleep 与 yield

sleep

• 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
• 其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
• 睡眠结束后的线程未必会立刻得到执行
• 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yieId

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

线程优先级

线程优先级会提示（hint）调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它

如果 cpu 比较忙，那么优先级高的线程会获得更多的时间片，但 cpu 闲时，优先级几乎没作用。

Runnable task1 = () -> {
    int count = 0;
    for (;;) {
        System.out.println("---->1 " + count++);
    }
};
Runnable task2 = () -> {
    int count = 0;
    for (;;) {
        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();

join

x.join() 等待 x 线程执行完后再继续。意味着同步操作。

下面的案例中，打印出的 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

解决方法：可以用 join()，加在 t1.start() 之后即可。

另外：join() 里面可以传毫秒，超过该时间就不等了，不超过的话等待时间就取决于线程本身了。

应用

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

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

看下面的代码，分别两个线程

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(1); //休眠1秒
            r1 = 10;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    },"t1");
    Thread t2 = new Thread(() -> {
        try {
            TimeUnit.SECONDS.sleep(2); //休眠两秒
            r1 = 20;
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    },"t2");
    t1.start();
    t2.start();
    long start = System.currentTimeMillis();
    log.debug("join begin");
    t1.join();//等待t1线程结束
    log.debug("t1 join end");
    t2.join();
    log.debug("t2 join end");
    long end = System.currentTimeMillis();
    log.debug("r1:{},r2:{},cost:{}",r1,r2,end-start);
}

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

第二个 join 1s 后执行到此 t2 也运行了 1s，因此也只需要等待 1s

interrupt

打断 sleep、wait 、join 的线程，这几个方法都会让线程进入阻塞状态

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

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

打断正常的线程

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(() -> {
        while(true) {
            boolean interrupted = Thread.currentThread().isInterrupted();
            if (interrupted) {
                log.debug("被打断，退出循环");
                break;
            }
        }
    },"t1");
    t1.start();
    Thread.sleep(1000);
    log.debug("interrupt");
    t1.interrupt();
}

过时不推荐

不推荐使用的方法，已过时且会造成锁的释放问题。

主线程和守护线程

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

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        while (true) {
            if (Thread.currentThread().isInterrupted()) {
            }
        }
    },"A");
    a.setDaemon(true);
    a.start();
    log.debug("end");
}

垃圾回收线程就是一种守护线程

Tomcat 中的 Acceptor 和 Poller 线程就是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待他们处理完请求。

总结

线程创建

线程重要 api 如 start run sleep join interrupt

线程状态

应用方面

• 异步调用：主线程执行期间，其他线程异步执行耗时操作
• 提高效率：并行计算，缩短运算时间
• 同步等待：join
• 统筹规划： 合理使用他线程 得到最优效果

原理方面

• 线程运行流程：栈、栈帧、上下文切换、程序计数器
• Thread 两种创建方式的源码

模式方面

• 终止模式之两阶段终止

线程状态

五种状态

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

【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联

【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行

【运行状态】指获取了 CPU 时间片运行中的状态，当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换

【阻塞状态】

• 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
• 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
• 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

六种状态

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

NEW 线程刚被创建，但是还没有调用 start() 方法

RUNNABLE 当调用了 start() 方法 注意，Java API 层面的 RUNNABLE 状态覆盖操作系统层面的可以运行状态、运行状态和阻塞状态， (由于BIO 导致线程阻塞，在 Java 里无法区分，任然认为可以运行。

BOLCKED、WAITING、TIMED_WAITING 都是 Java API 层面堆【阻塞状态】的细分，之后会慢慢解释。

TERMINATED 当线程代码运行结束。

新建 、可运行（就绪）、阻塞、等待、死亡、定时等待

共享模型之管程

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

共享带来的问题

故事启发

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

小南、小女（线程）来使用这个算盘来进行一些计算，并按照时间给老王支付费用。

但小南不能一天24小时使用算盘，他经常要小憩一会（sleep），又或是去吃饭或上厕所（阻塞 io 操作），有时还需要抽一根烟，没烟时思路全无（wait），这些情况统称为（阻塞）。

在这些时候，算盘没利用起来（不能收钱了），老王觉得有点不划算；另外，小女也想用用算盘，如果总是小南占着算盘，让小女觉得不公平。于是，老王灵机一动，想了个办法，让他们每人用一会，轮流使用算盘，这样，当小南阻塞的时候，算盘可以分给小女使用，不会浪费，反之亦然。

最近执行的计算比较复杂，需要存储一些中间结果，而学生们的脑容量（工作内存）不够，所以老王申请了一个笔记本（主存），把一些中间结果先记在本上。

但是由于分时系统，有一天还是发生了事故，小南刚读取了初始值 0 做了个 +1 运算，还没来得及写回结果，老王说 ”小南，你的时间到了，该别人了，记住结果走吧。“，于是小南不甘心地到一边待着去了（上下文切换）。

老王说 “小女，该你了 ”，小女看到了笔记本上还写着 0 做了一个 -1 运算，将结果 -1 写入笔记本，这时小女的时间也用完了，老王又叫醒了小南：“小南，把你上次的题目算完吧”，小南将他脑海中的结果 1 写入了笔记本。

最终结果变成了 1

小南和小女都没错，一个 +1；一个 -1；但是笔记本最终结果却是 1 而不是 0

在代码中的体现

两个线程堆初始值为 0 的静态变量一个做自增，一个做自减，各做 5000 次，结果还是 0 吗？

public class Test1 {
    static int counter = 0;
    static Object lock = new Object();
    @Test
    public void test1() throws InterruptedException {
        Room room = new Room();
        long begin = System.currentTimeMillis();
        Thread t1 = new Thread(() -> {
            for(int i = 0; i < 5000; i++) {
                room.increment();
            }
        },"t1");
        Thread t2 = new Thread(() -> {
            for(int i = 0; i < 5000; i++) {
                room.decrement();
            }
        },"t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        log.debug("{}, time={}", room.getCounter(), (end-begin));
    }
}
class Room {
    private int counter = 0;
    public void increment() {
        synchronized (this) {
            counter++;
        }
    }
    public void decrement() {
        synchronized (this) {
            counter--;
        }
    }
    public int getCounter() {
        synchronized (this) {
            return counter;
        }
    }
}

以上的结果可能是正数，负数，零。因为对 Java 中的静态变量自增，自减并不是原子操作，要彻底理解，必须从字节码来进行分析。

类如对于 i++ 而言（i 为静态变量），实际会产生如下JVM字节码指令

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

而对于 i--

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

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

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

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

出现正数情况

临界区 CriticalSection

一个程序运行多个线程本身是没有问题的

问题出在多个线程访问共享资源

• 多个线程读共享资源其实也是没有问题的
• 在多个线程对共享资源读写操作时发生指令交错，就会出现问题

一段代码内如果存在对共享资源的多线程读写操作，称这段代码为临界区

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

竞态条件 RaceCondition

多个线程在临界区内执行，由于代码的执行序列不同而导致结果无法预测，称之为发生了竞态条件

synchronized

思考分析

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

阻塞式的解决方案：synchronized Lock

非阻塞式的解决方案 原子变量

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

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

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

synchronized(对象) {
    临界区
}

synchronized 实际是用【对象锁】保证了临界区的代码的原子性，临界区的代码对外不可分割，不会被线程切换所打断。事实上，当某临界区的代码在执行时，还是会发生了上下文切换的，其他线程的临界区代码运行时由于【对象锁】被阻塞，继续发生上下文切换，直到之前的线程临界区代码执行完毕。

synchronized(对象) 中的对象，可以想象为一个房间（room），有唯一入口（门），房间只能一次进入一人进行计算，线程 t1，t2 想象成两个人。

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

面向对象改进

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

class Room {
    private int counter = 0;
    public void increment() {
        synchronized (this) {
            counter++;
        }
    }
    public void decrement() {
        synchronized (this) {
            counter--;
        }
    }
    public int getCounter() {
        synchronized (this) {
            return counter;
        }
    }
}

方法上的 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 锁住的是哪个对象

情况1：1-2 或 2-1

@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后-1-2 或 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-1-2 或 2-3-1s-1 或 3-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 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后-1-2 或 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后-1-2 或 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();
}

变量的线程安全分析

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

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

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

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

局部变量是否线程安全？

局部变量是线程安全的，但局部变量引用的对象未必

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

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

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

每个线程调用test1()方法时，局部变量 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 就会报错。

• 无论那个线程中的 method2 引用的都是同一个对象中的list成员变量
• method3 与 method2 分析相同

将 list 修改为局部变量

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：在情况一的基础上，为 ThreadSate 类添加子类，子类覆盖 method2 和 method3 方法即可

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);
    }
}
class ThreadSafeSubClass extends ThreadSafe{
    @Override
    public void method3(ArrayList<String> list) {
        new Thread(() -> {
            list.remove(0);
        }).start();
    }
}

从这个例子可以看出 private 或 final 提供安全的意思，这就是开闭原则中的闭

常见的线程安全类

• String
• Integer
• StringBuffer
• Random
• Vector
• Hashtable
• Java.util.concurrent 包下类

线程安全是指：多个线程调用他们同一个实例或某个方法时，是线程安全的

Hashtable table = new Hashtable();
new Thread(()->{
    table.put("key", "value1");
}).start();
new Thread(()->{
    table.put("key", "value2");
}).start();

在这些方法里的源码中都加了 synchronized，所以他们每个方法是原子的，但他们多个方法的组合不是原子的，下面分析

Hashtable table = new Hashtable();
// 线程1，线程2
if( table.get("key") == null) {
    table.put("key", value);
}

【线程1】执行完 get() 后，还是会发生上下文切换的，而且锁也会释放，因此这时候【线程2】可能会抢夺资源执行代码。

不可变类线程安全性

String，Integer 等都是不可变类，因为其内部的状态不可以改变，因此他们的方法都是线程安全的。

String 有 replace，substring 等方法都可以改变值 ，那么这些方法又是如何保证线程安全的，其实它们是返回了一个新的字符串，通过复制等方式。

案例分析

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) {
        // 使用上述变量
    }
}

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++;
    }
}

@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));
    }
}

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) {
            // ...
        }
    }
}

压根没有共享的成员变量

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();
    }
}

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

就这例子而言，虽没有线程安全问题，但依旧不推荐这样写，建议把 Connection 写入局部变量。

public abstract class Test {
    public void bar() {
        // 是否安全
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        foo(sdf);
    }
    public abstract foo(SimpleDateFormat sdf);
    public static void main(String[] args) {
        new Test().bar();
    }
}

其中 foo 的行为是不确定的，例如被重写，可能导致不安全的发生，被称之为外星方法

public void foo(SimpleDateFormat sdf) {
    String dateStr = "1999-10-11 00:00:00";
    for (int i = 0; i < 20; i++) {
        new Thread(() -> {
            try {
                sdf.parse(dateStr);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

比较 JDK 中 String 类的实现

练习

买卖票练习

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        TicketWindow window = new TicketWindow(1000);
        //所有线程的集合
        //这里不需要用线程安全的类，因为只有 main 线程
        List<Thread> threadList = new ArrayList<>();
        //卖出的票数统计
        List<Integer> amountList = new Vector<>();
        for(int i = 0; i< 2000; i++) {
            Thread thread = new Thread(() -> {
                //让线程安全问题在测试时更明显
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //买票
                int amount = window.sell(randomAmout());
                //保存卖票数量
                //Vector 是线程安全类
                amountList.add(amount);
            });
            //保存线程组，只有 main 线程，不用考虑线程安全
            threadList.add(thread);
            thread.start();
        }
        //等待线程执行完毕，统计结果
        for (Thread thread : threadList) {
            thread.join();
        }
        log.debug("余票:{}",window.getCount());
        log.debug("卖出的票数:{}",amountList.stream().mapToInt(i->i).sum());
    }
    //Random 是线程安全类
    static Random random = new Random();
    //随机1-5
    public static int randomAmout() {
        return random.nextInt(5) + 1;
    }
}
//售票窗口
class TicketWindow {
    private int count;
    public TicketWindow(int count) {
        this.count = count;
    }
    public int getCount() {
        return count;
    }
    //转账操作，操作了共享变量，因此这里临界区加上 synchronized 可解决线程安全问题
    public synchronized int sell(int amount) {
        if (this.count >= amount) {
            this.count -= amount;
            return amount;
        } else {
            return 0;
        }
    }
}

转账练习

下面是有线程安全问题的代码

@Slf4j
public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        Account a = new Account(1000);
        Account b = new Account(1000);
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                a.transfer(b, randomAmount());
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                b.transfer(a, randomAmount());
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.info("total: {}", a.getMoney() + b.getMoney());
    }
    // Random 为线程安全
    static Random random = new Random();
    /**
     * 随机 1~100
     */
    public static int randomAmount() {
        return random.nextInt(100) + 1;
    }
}
class Account {
    private int money;
    public Account(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public void transfer(Account target, int amount) {
        if (this.money > amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }
}

从这里我们分析，这里的 transfer 是临界区，但是可以直接在方法上加 synchronized 吗？不能，这样锁住的是 this，a b 是两个不同的实例。因此我们可以考虑使用 synchronized(Account.class) ，这样做可以达到线程安全的问题，但是效率不高，后面会继续优化。

public void transfer(Account target, int amount) {
    synchronized (Account.class) {
        if (this.money > amount) {
            this.setMoney(this.getMoney() - amount);
            target.setMoney(target.getMoney() + amount);
        }
    }
}

Monitor概念

Java对象头

有兴趣了解的可以参考 https://stackoverflow.com/questions/26357186/what-is-in-java-object-header

Monitor(锁)

Monitor 翻译为 监视器 或 管程

每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量锁）之后，该对象头的 Mark Word 中就被设置指向 Monitor 对象的指针。

刚开始时 Monitor 中的 Owner 为 null

当 Thread2 执行 synchronized(obj) 就会将 Monitor 所有者 Owner 置为 Thread-2，Monitor 中只能有一个 Owner

当 Thread2 上锁的过程中，如果Thread3，Thread4，Thread5 也来执行 synchronized(obj)，就会进入 EntryList BLOCKED

Thread2 执行完同步代码块，唤醒 EntryList 中等待的线程来竞争锁，竞争时是非公平的，具体由 JDK 底层决定

图中 WaitSet 中存放的是之前获得过锁的 Thread，但条件不满足进入 WAITING 状态的线程，后面会讲到 wait-notify 时分析

注意：synchronized 必须是进入同一个对象的 Monitor 才有上述的效果，不加 synchronized 的对象不会关联 Monitor，不遵从以上规则。

工作原理

我们从字节码的角度来分析 Monitor 原理，其实也是 synchronized 的

static final Object lock = new Object();
static int counter = 0;
public static void main(String[] args) {
    synchronized (lock) {
        counter++;
    }
}

如上面这段代码，分析出的字节码如下：

synchronized优化原理