多线程(四)：线程安全

在开始讲解线程安全之前我们先来回顾一下我们学了那些东西了：

1. 线程和进程的认识

2. Thread 类的基本用法

3. 简单认识线程状态

4. 初见线程安全

上一章结束时看了一眼线程安全问题，本章将针对这个重点讲解。

一个代码在单线程中能够安全执行，但是在多线程中就容易出现错误；其本质原因就是线程在系统中的调度是无序的 / 抢占式执行的。

再看一眼上一章末尾的题，两个线程各执行 5w 次自增操作，最后的结果为什么是一个小于 10w 的随机数。

上节课也画了图：

线程不安全的原因

我们在这里讨论一下照成线程不安全的原因有哪些？

多线程的抢占式执行（罪魁祸首）
多个线程修改同一个变量【如果是一个线程修改一个变量 => 安全】【多个线程读取一个变量 => 安全】【多个线程修改不同变量 => 安全】
修改操作不是原子的
内存可见性引起的线程不安全
指令重排序引起的线程不安全

那么我们就开始本章内容的讲解

对于 多线程的抢占式执行 和 多个线程修改同一个变量 这两点不是我们能够改变的，我们就直接跳过，直接看第三条

修改操作不是原子的

这里说到的原子性，数据库中事物的原子性是一个概念，原子性意味着不可再分，说明每个操作都是最小单位。

例如上述例题：每次自增操作都不算是最小操作，我们还可以对其进行划分，将一次 add 操作，分为三个小操作：load 、 add 、 save ；

任意某个操作对应单个 cpu 指令就是原子的，对应多个 cpu 操作就是非原子的。

正是应该这个操作不是原子的，导致了俩个线程的指令排序存在更多的变数

既然我们发现了这个问题了，我们该如何解决呢？

保证操作的原子性

既然它不是原子的，那么我们就可以通过加锁操作让它变成原子性的。

就比如：

我们要上厕所，为了让别人也进来，所以需要锁门，我们就给门加了个锁，那么上完厕所以后，就解锁，剩下的两个人就继续抢占式上厕所。

那么这个锁呢就可以保证 “原子性” 的效果

锁的核心操作就两个，加锁和解锁。

对于上述的一个锁，当谁抢到了，其他线程就需要等待，也就发生了阻塞等待，直到拿到锁的线程释放为止。

那么如何对线程进行加锁呢？

加锁和解锁

Java提供了关键字：synchronized，Java直接用 synchronized 这个关键字实现加锁过程。

还是上一章中最后一段的线程自增 5w 次的例子：

代码如下

class Count {
    private int count = 0;
    public void add() {
        synchronized (this) {
            count++;
        }
    }
    public int get() {
        return count;
    }
}
public class demo11 {
    public static void main(String[] args) throws InterruptedException {
        Count count = new Count();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count.add();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                count.add();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println(count.get());
    }
}

唯一不同的点在于：

我们加了关键字。

这里给它加了个代码块，这个代码块有啥用呢？

一旦进入被 synchronized 修饰的代码块时，就出发加锁机制，一旦离开了这个代码块就会触发解锁机制。

而且我们在 synchronized 后面加了一个（this）这里的 this 就是锁对象。

谁调用 this 就是谁，就对谁进行加锁操作。

例如：

如果两个线程，针对同一个对象进行加锁，就会造成锁竞争（一个拿到锁，另一个线程阻塞等待）。如果两个对象针对不同的锁竞争就不会照成锁竞争。

现在重点来说一下锁括号里面的东西：

（）里的锁对象，可以是写作任意一个Object 对象，但是不能是内置类型（内置类型就是基本数据类型）。

这括号主要就是为为了告诉大家,多个线程针对同一个对象加锁就会出现锁竞争,如果针对不同的对象加锁,就不会出现锁竞争了,再也没有别的作用

加锁以后,操作就变成原子的了,原来的操作就变成为了：

那么再次执行的时候就变成为了：

由于 t1 已经率先lock 了，t2 再次尝试 lock 就会出现阻塞等待的情况。

此时就可以保证 t2 的load 一定是在 t1 save 之后，此时计算的结果就一定是安全的。

加锁的本质其实就是变成串行化。

那么对比 join 方法，join也是实现串行化，join 方法是让两个线程都是实现串行化，而加锁只是让加锁的部分串行，其他部分还是并发执行的。

无论如何，加锁可能会造成阻塞，代码阻塞，对于程序的效率还是会有影响的。

内存可见性引起的线程不安全

我们先来写个 bug 在来说原因。

看代码：

import java.util.Scanner;

public class demo12 {
    public static boolean flag = false;
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            while (!flag) {

            }
        });
        Thread t2 = new Thread(() -> {
            Scanner scanner = new Scanner(System.in);
            flag = scanner.nextBoolean();
        });
        t1.start();
        t2.start();
    }
}

我们在来运行一遍：