线程的安全问题

1.线程的状态

1.1观察线程的所有状态

线程的状态是一个枚举类型Thread.State

public class ThreadState {
 public static void main(String[] args) {
 for (Thread.State state : Thread.State.values()) {
 System.out.println(state);
 }
 }
}

• NEW ：安排了工作，还未开始行动
• RUNNABLE:可工作的，又可以分成正在工作中和即将开始工作。
• BLOCKED：这几个都表示排队等着其他事情。带有超时时间的等。
• WAITING：这几个都表示排队等着其他事情。因为“死等”进入的阻塞
• TIMED_WAITING：这几个都表示排队等着其他事情
• TERMINATED：工作完成了。Thread对象还在。

3.2观察线程的状态和转移

观察1：关注NEW、RUNNABLE、TERMINATED状态的转换

public class ThreadStateTransfer {
 public static void main(String[] args) throws InterruptedException {
 Thread t = new Thread(() -> {
 for (int i = 0; i < 1000_0000; i++) {
 }
 }, "李四");
 System.out.println(t.getName() + ": " + t.getState());;
 t.start();
 while (t.isAlive()) {
 System.out.println(t.getName() + ": " + t.getState());;
 }
 System.out.println(t.getName() + ": " + t.getState());;
 }
}

观察2：关注WAITING、BLOCKED、TIMED_WAITING状态的转换。

public static void main(String[] args) {
 final Object object = new Object();
 Thread t1 = new Thread(new Runnable() {
 @Override
 public void run() {
 synchronized (object) {
 while (true) {
 try {
 Thread.sleep(1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 }
 }
 }
 }
 }, "t1");
 t1.start();

Thread t2 = new Thread(new Runnable() {
 @Override
 public void run() {
 synchronized (object) {
 System.out.println("hehe");
 }
 }
 }, "t2");
 t2.start();
}

结论：

1.BLOCKED 表示等待获取锁，WAITING和TIMED_WAITING表示等待其他进程发来通知。

2.TIMED_WAITING线程在等待唤醒，但设置了时限；WAITING线程在无限等待唤醒。

2.多线程带来的风险-线程安全（重点）

2.1观察线程不安全

// 此处定义⼀个 int 类型的变量
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
 Thread t1 = new Thread(() -> {
// 对 count 变量进⾏⾃增 5w 次
 for (int i = 0; i < 50000; i++) {
 count++;
 }
 });
 Thread t2 = new Thread(() -> {
 // 对 count 变量进⾏⾃增 5w 次
 for (int i = 0; i < 50000; i++) {
 count++;
 }
 });
 t1.start();
 t2.start();
 // 如果没有这俩 join, 肯定不⾏的. 线程还没⾃增完, 就开始打印了. 很可能打印出来的 cou
 t1.join();
 t2.join();
// 预期结果应该是 10w
 System.out.println("count: " + count);
}

2.2线程安全的概念

如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，这说明这个程序是线程安全的。

2.3线程不安全的原因

线程调度是随机的

这是线程安全问题的罪魁祸首

随机调度使一个程序在多线程环境下，执行顺序存在很多的变数。

我们要保证在任意执行顺序下，代码都能够正常工作。

2.3.1修改共享数据

多个线程修改同一个变量

上面的线程不安全代码中，涉及到多个线程针对count变量修改

此时这个count是一个多个线程都能访问的”共享数据”。

2.3.2原子性

我们把一段代码想象成一个房间，每个线程就是进入这个房间的人。如果没有任何机制保证，A进入房间之后，还没有出来；B是不是也可以进入房间，打断A在房间里的隐私。这个就是不具备原子性的。

那我们该如何判断这个问题呢？是不是只要给房间加一把锁，A进去就把门锁上，其他人是不是就进不去；1，这样就能保证这段代码的原子性。

有时也把这个现象叫做同步互斥，表示操作是相互排斥的。

一条java语句不一定是原子的，也不一定只是一条指令

比如：n++,其实是由三步操作组成的：

1. 从内存把数据读到CPI
2. 进行数据更新
3. 把数据写回到cpu

不保证原子性会给多线程带来什么问题

如果一个线程正在对一个变量操作，中途其他线程插入进来了，如果这个操作被打断了，结果就可能是错误的

这点也和线程的抢占式调度密切相关，如果线程不“抢占”的，就算没有原子性，也问题不大

2.3.3可见性

可见性，一个线程对共享变量值的修改，能够及时的被其他线程看到。

Java内存模型（JVM）：java虚拟机规范中定义了java内存模型。

目的是屏蔽各种硬件和操作系统的内存访问差异，以实现让java程序在各个平台下能达到一致的并发效果。

• 线程之间的共享变量存在 主内存（Main Memory）。
• 每一个线程都有自己的“工作内存”（working Memory）。
• 当线程要读取一个共享变量的时候，会先把变量从主内存拷贝到工作内存中，再从工作内存中读取数据。
• 当线程要修改一个共享变量的时候，也会先修改工作内存中的副本，在同步回到主内存。

由于每一个线程都有自己的工作内存，这些工作内存中的内容相当于同一个共享变量的“副本”，此时，修改线程1的工作内存的值，线程2的工作内存也不一定会发生及时变化。

（1）初始情况下，两个线程的工作内存内容一致。

（2）一旦线程1修改了a的值，此时内存内不一定能及时同步，对应的线程2的工作内容的a的值也不一定能及时同步。

这个时候代码就容易出现问题。

2.3.4指令重排序

一段代码是这样的：

1. 去前台取下U盘
2. 去教室写10分钟作业
3. 去前台取下快递

如果是在单线程的情况下，JVM、CPU指令集会对其进行优化，比如，按照132的方式执行，也是没问题，可以少跑一次前台。这种叫做指令重排序。

编译器在对于指令重排序的前提是“保持逻辑不发生变化”，这一点在单线程下比较容易判断，但是在多线程环境下就没有那么容易了，多线程的代码执行程度更加复杂，编译器很难在编译阶段对代码的执行效果进行预测，因此激进的重排序很容易导致优化后的逻辑和之前的不等价。

2.4解决之前的线程不安全问题

// 此处定义⼀个 int 类型的变量
private static int count = 0;
public static void main(String[] args) throws InterruptedException {
 Object locker = new Object();
 Thread t1 = new Thread(() -> {
 // 对 count 变量进⾏⾃增 5w 次
 for (int i = 0; i < 50000; i++) {
 synchronized (locker) {
 count++;
 }
}
});
Thread t2 = new Thread(() -> {
 // 对 count 变量进⾏⾃增 5w 次
 for (int i = 0; i < 50000; i++) {
 synchronized (locker) {
 count++;
 }
 }
 });
 t1.start();
 t2.start();
 // 如果没有这俩 join, 肯定不⾏的. 线程还没⾃增完, 就开始打印了. 很可能打印出来的
 t1.join();
 t2.join();
 // 预期结果应该是 10w
 System.out.println("count: " + count);
}