什么是原子性可见性有序性?java内存模型是如何把保证原子性可见性有序性的

最新推荐文章于 2024-09-21 11:25:09 发布
最新推荐文章于 2024-09-21 11:25:09 发布
阅读量592 收藏 2
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41174684/article/details/90613757
博客介绍了原子性、可见性、有序性的概念。原子性指操作不被中断，基本数据类型读写多为原子操作；可见性指线程修改共享变量，其他线程能马上获取；有序性在单线程按顺序执行，多线程可能乱序。还阐述了Java内存模型通过多种方式解决这三性问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

什么是原子性、可见性、有序性？

原子性：

原子性指的是一个操作不会被中断，操作不会受到其他线程的影响。两个线程同时对一个变量赋值，则该值要么是1要么是2，线程A和线程B互不干扰，不会被中断。

要知道基本数据类型中六种类型的读写操作都是原子操作(byte short int float char boolean )，long double 因为是64位的，以此在32位的虚拟机要进行两次读取，不是原子操作，但是现在的虚拟机大部分是64位的，long double 类型的读写也是原子操作

可见性：

可见性指的是一个线程修改共享变量的值，其他线程能够马上得到这个修改的值。

工作内存和主内存之间就会产生可见性问题，当一个线程修改某个主内存中的共享变量的时候，线程会拷贝一个变量的副本存放到工作内存中，线程对这个变量已经做出了修改，但是还没有刷新到内存中，其他线程从内存中读取该变量的值时候，看不见线程对共享变量做出的修改，指令重排序的编译器优化重排序，处理器的指令并行重排序，处理器的内存系统重排序可能会造成可见性的影响
有序性:

有序性指的是单线程中代码的执行总是按照循序执行的，多线程中可能出现乱序顺序，程序编译成字节码指令的时候可能会出现重排序现象，重排后的指令与原指令的顺序比一定一致。另一种角度:在一个线程内所有的操作都是有序的，但是在多线程下，一个线程观察另一个线程，所有的操作都是无序的，因为可能存在指令重排序和工作内存和主内存的同步延迟。编译器和处理器的重排序有编译器优化重排序，指令级并行重排序，内存系统的重排序

java内存模型解决原子性、可见性、有序性

原子性问题基本数据类型的变量的读写操作已经自动保证原子性，使用synchronized或者是ReentrantLock保证方法(静态方法，实例方法)和代码块的原子性。工作内存和主内存之间的同步延迟造成的可见性问题使用synchrozied和volatile解决，能够使得在一个线程中修改的变量立即对其他线程可见，指令重排序带来的可见性问题，编译器优化重排序java内存模型的编译器重排序规则会禁止特定类型的重排序，指令并行重排序和内存系统的重排序java内存模型的处理器重排序规则要求编译器在生成指令序列的时候，插入特定类型的内存屏障指令通过内存屏障指令来禁止特定类型的重排序。对于重排序问题，使用volatile，编译器重排序规则和处理器重排序规则来解决，同时happens-before规则也保证多线程环境下两个操作之间的原子性，可见性，有序性

从JDK源码角度看java并发的原子性如何保证
seaboat——a free boat on the sea.（公众号：远洋号）
05-10 5631
JDK源码中，在研究AQS框架时，会发现很多地方都使用了CAS操作，在并发实现中CAS操作必须具备原子性，而且是硬件级别的原子性，java被隔离在硬件之上，明显力不从心，这时为了能直接操作操作系统层面，肯定要通过用C++编写的native本地方法来扩展实现。JDK提供了一个类来满足CAS的要求，sun.misc.Unsafe，从名字上可以大概知道它用于执行低级别、不安全的操作，AQS就是使用此类完
Java并发编程面试题——线程安全（原子性、可见性、有序性）
二蛋的博客
02-16 4961
一、原子性高频问题 1.1 Java中如何实现线程安全? 1.2 CAS底层实现 1.3 CAS的常见问题 1.4 四种引用类型 + ThreadLocal的问题？ 二、可见性高频问题 2.1 Java的内存模型 2.2 保证可见性的方式 2.3 volatile修饰引用数据类型 2.4 有了MESI协议，为啥还有volatile？ 2.5 volatile的可见性底层实现 三、有序性高频问题 3.1 什么是有序性问题 3.2 volatile的有序性底层实现 四、synchronized高频问题 4.1
Java 常见原子操作
张紫娃的博客
12-19 554
3、Java内存模型只保证了基本读取和赋值的原子性操作，其他的均不保证，如果想要使得某些代码片段具备原子性，需要使用关键字。对基本数据类型的变量读取赋值操作都是原子性的，对引用类型的变量读取和赋值的操作也是原子性的。，因此诸如此类的操作是不可被中断的，要么执行，要么不执行，正所谓一荣俱荣一损俱损。2、简单的读取与赋值操作是原子性的，将一个变量赋给另外一个变量的操作不是原子性的。如果想要使得int等类型自增操作具备原子性，可以使用JUC包下的。1、多个原子性的操作在一起就不再是原子性操作了。
详解 Java 内存模型与原子性、可见性、有序性
lyzchengxuyuan的博客
01-03 334
原子性 什么是原子性 类比物理机，拥有缓存一致性协议来规定主内存和高速缓存之间的操作逻辑，那么 JMM 中主内存与工作内存之间有没有具体的交互协议呢？ Of Course！JMM 中定义了以下 8 种操作规范来完成一个变量从主内存拷贝到工作内存、以及从工作内存同步回主内存这一类的实现细节。Java 虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的。 暂时放下到底是哪 8 种操作，我们先谈何为原子？ 原子（atomic）本意是 “不能被进一步分割的最小粒子”，而原子操作（atomic opera
Java多线程——如何保证原子性_java怎么保证原子性
2401_87109462的博客
09-12 695
t2.start();i < 20;//1、计算任务，实现Callable接口i < 20;// 耗时操作return “计算结果：” + sum;//2、创建FutureTask，传入callable对象//3、创建启动线程try {
Java里面的atomic类是如何保证原子性的
xuweilin的博客
09-21 618
Java中的Atomic类通过几种机制共同协作来保证原子性，这些机制主要包括CAS（Compare And Swap）操作、volatile关键字以及底层的本地方法。
14、深入理解并发可见性、有序性、原子性与JMM内存模型
03-07
深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发可见性、有序性、原子性与JMM内存模型深入理解并发...
Java内存模型--原子性；有序性；可见性1
08-08
总结来说，Java内存模型通过原子性、有序性和可见性保证了多线程环境下的数据一致性。理解并熟练运用这些概念是编写高效、线程安全的Java代码的基础。在实际开发中，应根据需求选择合适的方式来确保这三个特性，以...
Java如何实现并发的原子性、可见性和有序性
qq_48241564的博客
01-11 1075
目录 一、原子性 1、原子性原理 2、测试代码 二、可见性 1、可见性原理 2、测试代码 2.1、synchronized和lock也能实现可见性 2.2、添加volatile关键字也能实现可见性 三、有序性 1、有序性原理 2、测试代码 一、原子性 1、原子性原理 一个操作或者多个操作要么全部执行并且执行的过程不被任何因素打断，要么都不执行。 2、测试代码 按正常的运行结果来说它应该是20000，但运行结果却并不是，产生的原因是有几个线程点，两个线程都读完了然后进行加一
Java内存模型可见性问题相关解析
08-25
总结来说，Java内存模型中的可见性问题是指线程之间无法立即感知共享变量的修改。通过使用`volatile`关键字，可以确保修改的变量对其他线程的可见性，避免因缓存导致的数据不一致。但在处理多线程的并发问题时，还...
Java是怎么保证原子性，可见性
西红柿炒土豆
10-13 1148
先来谈谈yaunzixing
Java多线程——如何保证原子性
Arya的博客，专注后端领域
03-06 1604
Java多线程——如何保证原子性。
Java并发编程之如何保证原子性（一）
会飞的小蜗
06-25 2509
文章目录进程与线程并发编程需要解决的三特性和三问题 ### 首先说什么是并发？ 并发是一种能并行运行多个程序或并行运行一个程序中多个部分的能力。如果程序中一个耗时的任务能以异步或并行的方式运行，那么整个程序的吞吐量和可交互性将大大改善。现代的PC都有多个CPU或一个CPU中有多个核。是否能合理运用多核的能力将成为一个大规模应用程序的关键。 进程与线程 进程是以独立于其他进程的方式运行的，进程间是互相隔离的。一个进程无法直接访问另一个进程的数据。进程的资源诸如内存和CPU时间片都是由操作系统来分配。 线程
java内存模型的三大特性分别是原子性 ，可见性，有序性（volatile 保证可见性，有序性，但不保证原子性）
weixin_44893467的博客
07-16 312
三大特性分别是原子性 ，可见性，有序性 原子性：指一个操作是不可中断的，即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰 可见性：指当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道这个修改。显然，对于串行程序来说，可见性问题 是不存在。因为你在任何一个操作步骤中修改某个变量，那么在后续的步骤中，读取这个变量的值，一定是修改后的新值。但是这个问题在并行程序中就不见得了。如果一个线程修改了某一个全局变量，那么其他线程未必可以马上知道这个改动。 有序性：对于一个线程的执行代码而言
Java内存模型中原子性，可见性和有序性处理
calm_encode的博客
09-15 325
一 概述 Java的内存模型是围绕着在并发过程中如何处理原子性，可见性和有序性这三个特征来建立的。 二 原子性（Atomicity） 由Java内存模型来直接保证的原子性操作包括read，load，assign，use，store和write这六个，大致认为基本数据类型的访问，读写都是具有原子性的（long和double的非原子性协定除外）。 Java为了满足更大范围的原子性保证，Java内存模型还提供了lock和unlock操作来满足这种需求，尽管虚拟机没有将lock和unlock的操作直接开放给
同步与Java内存模型（原子性,可见性,有序性）
Code-lover's Learning Notes
03-27 3250
同步与Java内存模型(一)序言先来看如下这个简单的Java类，该类中并没有使用任何的同步。final class SetCheck { private int a = 0; private long b = 0; void set() { a = 1; b = -1; } boolean check() { r
JAVA内存模型中的原子性、可见性与有序性
AllineedisU的博客
04-16 347
Java内存模型是围绕着线程在并发过程中如何处理原子性，可见性和有序性这3个特征来建立的。 原子性：由Java内存模型来直接保证的原子性变量操作由read,load,assign,use,store,write，我们大致可以认为基本类型的读写是具备原子性的。 可见性：可见性是指当一个线程修改变量值后，其他线程能立即知道这个修改，volatile实现可见是由于立即同步回主内存和使用前刷新来实现的...
并发编程 - 内存模型是如何保证原子性可见性有序性
Andy_Health的博客
06-30 225
原子性（操作是不可分、操作不可被中断）： Synchronized、Lock 可见性（保障数据的一致，数据安全一部分）： Volatile、Synchronized 有序性（按照自己想要执行的顺序执行线程）： Join 内存模型解决原子性、可见性、有序性 原子性问题基本数据类型(byte short int float char boolean )的变量的读写操作已经自动保证原子性，使用Synchronized或者是ReentrantLock保证方法(静态方法，实例方法)和代码块的原子性。 工作内存和主.
并发编程-锁的那些事儿【四：理解原子性，议Java如何保证原子产生的问题】
盘码客
10-12 282
前言 在前面章节，全面概括了并发三大特性，其中可见、有序性还是较为容易理解，并在前面章节都有对其做过场景理解说明，此篇单独对原子性做场景理解； 原子性特性 把一个或者多个操作在 CPU 执行的过程中不被中断的特性；Java内存模型中，直接保证了原子性变量操作【read，load，use，assign，store，wirte】，在应用中，可以大致认定基本类型操作读写具备原子性的，除了【long，do...
✅synchronized是如何保证原子性、可见性、有序性的？
最新发布
08-02
<think>我们正在讨论Java中synchronized关键字如何保证线程的原子性、可见性和有序性。根据用户提供的引用内容，我们可以从以下几个方面进行解释： 1. **原子性（Atomicity）**： - synchronized通过互斥锁（monitor lock）保证同一时刻只有一个线程可以执行同步代码块或同步方法。当一个线程获得锁后，其他试图获取同一把锁的线程会被阻塞，直到锁被释放。 - 这样，同步代码块内的操作就成为一个不可分割的整体，从而保证了原子性。 2. **可见性（Visibility）**： - 在释放锁时，JVM会强制将工作内存中的修改刷新到主内存中。 - 在获取锁时，JVM会强制使当前线程的工作内存中的缓存失效，从而从主内存中重新加载变量。 - 这种机制保证了在同步代码块内对共享变量的修改对其他线程是可见的。 3. **有序性（Ordering）**： - synchronized通过“互斥执行”来保证有序性。由于同步代码块内同一时间只能有一个线程执行，因此线程内的代码会按照程序顺序执行（即as-if-serial语义）。 - 另外，synchronized还会在进入锁时和释放锁时插入内存屏障（Memory Barrier），防止指令重排序越过屏障，从而保证了有序性。 接下来，我们结合引用内容详细说明： - 引用[1]指出，理解synchronized的原子性、可见性和有序性保证机制对多线程编程非常重要。 - 引用[2]提到，synchronized作为基础同步机制，在JDK优化下性能已大幅提升。 - 引用[3]说明，synchronized通过监视器锁（monitor lock）解决原子性、内存可见性和有序性问题。 - 引用[4]展示了使用AtomicInteger保证原子性的例子，而synchronized同样可以保证原子性。 - 引用[5]解释了原子性问题产生的原因（时间片轮换），而synchronized通过互斥解决了这个问题。 下面我们具体展开说明： ### 1. 原子性保证 synchronized关键字通过互斥锁（monitor lock）实现原子性。当线程进入synchronized代码块时，它会尝试获取对象的锁。如果获取成功，则执行代码块；如果失败，则阻塞等待。执行完代码块后，线程会自动释放锁。这样，整个代码块内的操作就成为一个原子操作，不会被其他线程中断。 例如，多个线程对同一个共享变量进行自增操作（非原子操作）时，使用synchronized可以保证自增操作的原子性： ```java public class Counter { private int count = 0; public synchronized void increment() { count++; // 原子操作 } } ``` ### 2. 可见性保证 synchronized通过以下机制保证可见性： - 当线程释放锁时，JVM会把该线程对应的本地内存中的共享变量刷新到主内存中。 - 当线程获取锁时，JVM会使该线程对应的本地内存无效，从而从主内存中重新读取共享变量。 这样，一个线程在同步代码块内对共享变量的修改，对其他线程是可见的。 ### 3. 有序性保证 synchronized通过以下机制保证有序性： - **程序顺序规则**：在同步代码块内，代码会按照程序顺序执行（即单线程内表现为串行）。 - **锁的互斥性**：同一时间只有一个线程执行同步代码块，因此不会出现多个线程操作交叉执行的情况。 - **内存屏障**：在进入锁（monitorenter）和退出锁（monitorexit）时插入内存屏障，禁止指令重排序越过屏障。 ### 总结 synchronized关键字通过内置锁（monitor）机制，同时保证了原子性、可见性和有序性： - **原子性**：通过互斥锁保证代码块内操作的不可分割性。 - **可见性**：通过锁释放时将修改刷新到主内存，锁获取时从主内存重新加载变量。 - **有序性**：通过程序顺序规则和内存屏障保证指令执行顺序。 这些特性使得synchronized成为Java中解决线程安全问题的基本工具。 §§相关问题§§ 1. synchronized锁升级的过程是怎样的？偏向锁、轻量级锁和重量级锁有什么区别？ 2. synchronized和ReentrantLock在可见性保证机制上有何异同？ 3. 为什么说synchronized的有序性保证是相对的？在什么情况下可能出现重排序问题？ 4. 如何通过JVM参数调整synchronized锁的行为（如偏向锁延迟）？</think>### Java中synchronized关键字如何保证线程的原子性、可见性和有序性 #### 一、原子性保证机制 **原理**：通过**监视器锁（Monitor Lock）** 实现互斥访问[^3] **实现过程**： 1. 当线程进入`synchronized`代码块时，自动获取对象关联的监视器锁（monitor lock） 2. 同一时刻仅允许一个线程持有该锁 3. 其他线程尝试获取锁时会被阻塞，进入**Entry Set**等待队列[^1] 4. 线程执行完同步代码后自动释放锁 **原子性体现**： ```java private int count = 0; public synchronized void increment() { count++; // 非原子操作变为原子操作 } ``` > 自增操作（读取-修改-写入）在多线程下本是非原子操作，通过`synchronized`将其封装为不可分割的原子操作[^5] #### 二、可见性保证机制 **原理**：通过**内存屏障（Memory Barrier）** 实现[^3] **具体机制**： 1. **锁释放屏障**： - 在monitorexit指令（释放锁）后插入**写屏障** - 强制将工作内存中的修改刷新到主内存 2. **锁获取屏障**： - 在monitorenter指令（获取锁）前插入**读屏障** - 强制从主内存重新加载共享变量 **可见性保证流程**： ```mermaid graph LR A[线程A修改数据] --> B[释放锁时写屏障] B --> C[数据刷入主内存] D[线程B获取锁] --> E[获取锁时读屏障] E --> F[从主内存加载最新数据] ``` > 保证了线程A对共享变量的修改对线程B立即可见[^1] #### 三、有序性保证机制 **原理**：通过**禁止指令重排序**实现[^5] **具体规则**： 1. **as-if-serial语义**： - 同步代码块内指令按程序顺序执行 - 单线程执行结果不被改变 2. **线程间约束**： - 遵循**监视器锁规则**：解锁操作先于后续加锁操作 - 遵循**传递性规则**：若A先于B，B先于C，则A先于C **内存屏障类型**： | 屏障类型 | 作用 | |---------------|------------------------------| | LoadLoad | 禁止读-读重排序 | | StoreStore | 禁止写-写重排序 | | LoadStore | 禁止读-写重排序 | | StoreLoad | 禁止写-读重排序（全能屏障） | #### 四、底层实现原理 **字节码层面**： ```java public void syncMethod(); Code: 0: aload_0 1: dup 2: astore_1 3: monitorenter // 获取锁 4: aload_1 5: monitorexit // 正常释放锁 8: goto 16 11: astore_2 12: aload_1 13: monitorexit // 异常释放锁（保证锁必然释放） 16: return ``` **内存语义实现**： 1. 获取锁 → 清空本地内存 → 从主内存加载共享变量 2. 释放锁 → 刷新本地内存修改 → 写入主内存 #### 五、与volatile的对比 | 特性 | synchronized | volatile | |-------------|----------------------------------|------------------------| | **原子性** | 完整代码块原子性 | 单次读/写原子性 | | **可见性** | 通过锁机制保证 | 直接内存可见性 | | **有序性** | 完全禁止重排序 | 禁止部分重排序 | | **使用方式**| 方法/代码块 | 变量修饰符 | | **性能** | 重量级（但JDK已优化）[^2] | 轻量级 | > 实际开发中优先考虑`synchronized`，除非是简单状态标志位场景[^2] ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值