【Java基础】线程的原子性、可见性、有序性及线程安全知识整理

要想保证线程安全，必须同时满足原子性、可见性、有序性。

一、定义

1.1 原子性

一个操作或者多个操作，要么全部执行，并且执行的过程不会被打断， 要么就全部不执行（一个操作是不可被分割的）。

Java中实现线程原子性主要有两种方式：

1、互斥锁：在同一时刻只允许一个线程对共享资源进行访问和操作，而其他线程则需要等待锁的释放才能继续执行。如：synchronized和ReentrantLock等机制来实现锁的获取、释放和等待。

2、原子变量类：Java提供了一些基本类型的原子变量类（如 AtomicInteger、AtomicBoolean 等），这些变量类保证了读取和修改操作的原子性，从而避免了线程安全问题。

我们来看下几个例子：

a = 0 是原子操作 
a++ (a = a + 1) 则不是。因为有两步操作。

我们看一段Java原子性测试代码，使用AtomicInteger类实现对一个共享变量的递增操作。AtomicInteger类提供了compareAndSet方法，可以在多线程并发操作时保证对共享变量的修改都是原子性的

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicTest implements Runnable {
    
    private AtomicInteger count = new AtomicInteger(0);
    
    public void run() {
        for (int i = 0; i < 10000; i++) {
            // 原子性自增
            count.incrementAndGet(); 
        }
    }
    //创建了两个线程，并在每个线程中执行10000次count.incrementAndGet()方法，
    //即对共享变量count进行原子性自增操作。最后在主线程中输出count的值
    public static void main(String[] args) throws InterruptedException {
        AtomicTest test = new AtomicTest();
        
        Thread thread1 = new Thread(test);
        Thread thread2 = new Thread(test);

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
        
        System.out.println("count=" + test.count.get());
    }
}

1.2 可见性

是指线程之间的可见性，一个线程修改的状态，对另一个线程是可见的。（也就是一个线程修改的结果，另一个线程能立马知道）。

在多线程并发编程中，由于每个线程都有自己线程栈和本地内存，因此存在一个问题：一个线程修改了共享变量的值，但是由于各种原因（比如缓存、处理器优化等），其他线程可能不会立即知道这个共享变量的最新值，这就导致了访问线程之间的数据不一致。

在java 中 synchronized、 final、 volatile实现可见性。

比如：使用volatile 修饰的变量，就具有可见性， volatile不允许线程内进行缓存和重排序，直接修改内存，所以对其他线程是可见的。

volatile虽然具有可见性，但不具有原子性：

eg:
我们定义一个变量，并进行 +1操作
volatile int i = 0;
i++；

此时i 具有可见性，但不具有原子性，如果多个线程同时对同一个volatile变量进行写操作，由于没有互斥机制，仍然会存在竞态条件问题。

1.3 有序性

程序执行时顺序按照代码但先后顺序执行。

比如下面这个，语句 1、2的顺序就可以调换， 3、4的则不行。

int a = 10;    //语句1
int r = 2;    //语句2
a = a + 3;    //语句3
r = a*a;     //语句4

二、线程安全

2.1、什么是线程安全

线程安全指内存的安全。这和操作系统有关，
在每个进程的内存空间中都会有一块特殊的公共区域，通常称为堆(内存)。
进程内的所有线程都可以访问到该区域，这就是造成问题的潜在原因。

所以线程安全指的是，在堆内存中的数据由于可以被任何线程访问到，
在没有限制的情况下存在被意外修改的风险。
即堆内存空间在没有保护机制的情况下，对多线程来说是不安全的地方，
因为你放进去的数据，可能被别的线程“破坏”。

2.2、为什么多线程不安全

进程中，有很多数据是多线程之间共享的，这些共享的数据很可能被其他线程修改了，那么线程之间共享了哪些进程资源呢？我们接着往下看，线程间数据的操作过程如下：

线程在执行时，先从主存中读取数据，然后复制一份到高速缓存中，
计算完后，再刷新到主存中。
 ____________      _______________
｜cpu  高速缓存｜   ｜  缓存一致性协议｜
. -----------     ｜              ｜
｜cpu  高速缓存｜   ｜       or     ｜      主存
. -----------     ｜              ｜
｜cpu  高速缓存｜   ｜   总线锁机制   ｜
. -----------     ｜______________｜

我们都知道进程是操作系统进行资源分配和调度的基本单位，线程thread是操作系统能够进行运算调度的最小单位，所以在某个进程里面，进程的所有资源对于这个进程里的所有线程来说是共享的，既然是共享的，所以在并发操作里，我们的数据就很有可能不安全，比如我们同时用两个线程对count1分别相加，等到的结果是不确定的。

2.2.1 哪些资源是线程私有的？

我们找到独属于线程的资源，其他的资源都是共享的，我们可以这么理解，线程运行的本质就是函数的执行，函数运行时的信息保存在栈帧中，栈帧中保存了函数的返回值、调用其它函数的参数、该函数使用的局部变量以及该函数使用的寄存器信息。

因此每个线程都有自己独立的、私有的栈区，
以上这些信息有一个统一的名字，就是线程上下文，thread context。

除此之外，剩下的都是线程间共享资源。
借用一张网络图片，如下

2.3 如何解决线程安全问题？

1、私有化
2、ThreadLocal
3、(互斥)锁
4、cas操作
等等