多线程三大性质：原子性，有序性和可见性

最新推荐文章于 2025-04-17 10:04:57 发布

Anvilliu

最新推荐文章于 2025-04-17 10:04:57 发布

阅读量422

点赞数

分类专栏：多线程文章标签：多线程 java 并发编程

本文链接：https://blog.csdn.net/sfjsww66/article/details/112228282

版权

多线程专栏收录该内容

2 篇文章

订阅专栏

原子性，有序性和可见性

原子性

原子性是指一个操作是不可中断的，要么全部执行成功要么全部执行失败，及时在多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程所干扰。

int a = 10; //1
a++; //2
int b=a; //3
a = a+1; //4

其中只有1是原子性操作，操作1只需要赋给a值为10，操作2需要读a的值，实行a+1操作，再将值赋给a。操作三需要读a的值，再赋给b，操作4同操作2。

java内存模型中定义了8中操作都是原子的，不可再分的。

lock(锁定)：作用于主内存中的变量，它把一个变量标识为一个线程独占的状态；
unlock(解锁):作用于主内存中的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定;
read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便后面的load动作使用；
load（载入）：作用于工作内存中的变量，它把read操作从主内存中得到的变量值放入工作内存中的变量副本;
use（使用）：作用于工作内存中的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作；
assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；
store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送给主内存中以便随后的write操作使用；
write（操作）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

可以大致认为基本数据类型的访问读写具备原子性（例外就是long和double的非原子性协定）。

除了访问读写的内容具备原子性，还剩下lock和unlock操作，反映在Java代码中就是synchronized关键字，也就是说synchronized满足原子性。

volatile关键字只能保证内存可见性和有序性，不能保证原子性，某个线程修改了一个值，这个修改的值对其他线程来说是立即可见的。但由于修改值这个操作是非原子性的，有可能两个线程同时读取了原先的值，其中一个先修改了，另一个再进行了修改，这样就导致少了一次修改。

如果让volatile保证原子性，必须符合以下两条规则：

运算结果并不依赖于变量的当前值，或者能够确保只有一个线程修改变量的值；
变量不需要与其他的状态变量共同参与不变约束

这句话的意思是

volatile static int start = 3;

volatile static int end = 6;

// 线程A执行如下代码：

while (start < end){

  //do something

}

// 线程B执行如下代码：

start+=3;

end+=3;

线程B可能让start先变为6，这样就破坏了线程A的不变约束。

有序性

顾名思义，程序执行的有序性就是说代码必须按一定顺序进行执行。

Java编译器和处理器在单线程上as-if-serial语义保证了顺序一致性，多线程上JMM以内部手段：happens-before原则保证了一定程度的顺序一致性，JMM还提供了一定的外部手段来保证多线程的有序性，即并发编程中的volatile,synchronized,锁,final等概念。

synchronized语义表示锁在同一时刻只能由一个线程进行获取，当锁被占用后，其他线程只能等待。因此，synchronized语义就要求线程在访问读写共享变量时只能“串行”执行，因此synchronized具有有序性。

在java内存模型中说过，为了性能优化，编译器和处理器会进行指令重排序；也就是说java程序天然的有序性可以总结为：如果在本线程内观察，所有的操作都是有序的（顺序一致性模型）；如果在一个线程观察另一个线程，所有的操作都是无序的。在单例模式的实现上有一种双重检验锁定的方式（Double-checked Locking）。

public class Singleton {
    private Singleton() { }
    private volatile static Singleton instance;
    public Singleton getInstance(){
        if(instance==null){
            synchronized (Singleton.class){
                if(instance==null){
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

上述创建的instance为什么要加volatile修饰呢，上述单例模式进行单例对象创建的时候，首先确认对象是不是为null，单例模式为了保证只有一个这样的对象实例所以需要检查是否存在这样的对象，确认为null后进行同步锁的获取，这里进行同步锁获取的目的是防止其他线程对其进行创建，从而产生多个对象。第二次确认instance为null是为了避免在第一次确认为null之后到获取锁之前，有其他线程获取了锁并创建了对象，此时也会重复创建，所以获取锁保证无其他线程操作以后，再次确认instance为null，才能创建单例对象。创建对象时，1.分配对象的内存空间；2.初始化对象；3.设置instance指向刚分配的内存地址。但由于存在重排序的问题，可能有以下的执行顺序：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Y0MOU5Wl-1609824445103)(https://secure-static.wolai.com/static/2ZpNnK8sbUWrUsTNLLYE6M/image.png)]

如果2和3进行重排序，那么instance在初始化之前就有了内存地址，线程B访问instance时就不为null，但是instance尚未初始化，所以这样会存在操作问题。因此要使用volatile对操作重排序进行限制。volatile包含禁止指令重排序的语义，其具有有序性。

可见性

可见性是指当一个线程修改了共享变量后，其他线程能够立即得知这个修改。通过之前对synchronzed内存语义进行了分析，当线程获取锁时会从主内存中获取共享变量的最新值，释放锁的时候会将共享变量同步到主内存中。从而，synchronized具有可见性。在volatile中，

生成汇编代码时会在volatile修饰的共享变量进行写操作的时候会多出Lock前缀的指令。主要有这两个方面的影响：

将当前处理器缓存行的数据写回系统内存；
这个写回内存的操作会使得其他CPU里缓存了该内存地址的数据无效

为了提高处理速度，处理器不直接和内存进行通信，而是先将系统内存的数据读到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到内存。如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。因此，经过分析我们可以得出如下结论：