首页
学习
活动
专区
圈层
工具
发布
    • 综合排序
    • 最热优先
    • 最新优先
    时间不限
  • 来自专栏吉林乌拉

    happens-before原则

    在Java中有一个很重要的原则,这个原则是判断线程是否存在数据竞争、线程是否安全的主要依据,这个原则就是happens-before原则。我们首先看一下到底什么是happens-before原则。 上述就是happens-before原则的定义,下面我们用一个简单的例子来说明一下happens-before原则到底有什么作用。 ? 原因就是根据happens-before原则,thread-1先行发生于thread-2,所以thread-1执行后的值,thread-2是可以获取到的,并且我们假设thread-3没有执行。 下面我们假设thread-1和thread-2还具有happens-before关系,也就是说thread-1在thread-2之前执行并且我们假设thread-2和thread-3并没有happens-before 如果代码中的操作没有happens-before原则的话,那么虚拟机在执行的时候,就有可能对它们进行随意的重排序。下面我们看一下在JMM中都有哪些操作是默认具有happens-before原则的。

    66030发布于 2019-08-14
  • 来自专栏多线程

    什么是happens-before原则

    线程内的happens-before 在同一个线程中,字节码的先后顺序(program order)也暗含了 happens-before 关系:在程序控制流路径中靠前的字节码 happens-before 线程间的 happens-before 解锁操作 happens-before 之后(这里指时钟顺序先后)对同一把锁的加锁操作。 线程的启动操作(即 Thread.starts()) happens-before 该线程的第一个操作。 构造器中的最后一个操作 happens-before 析构器的第一个操作。 happens-before关系的传递性 如果操作 X happens-before 操作 Y,而操作 Y happens-before 操作 Z,那么操作 X happens-before 操作 Z。

    37830编辑于 2023-10-16
  • 来自专栏Java成长之路

    先行发生原则(happens-before)介绍

    内存模型中所有的有序性都仅仅靠volatile和synchronized来完成,那么有一些操作将会变得很烦琐,但是我们在编写Java并发代码的时候并没有感觉到这一点,这是因为Java语言中有一个“先行发生”(happens-before )的原则。 这个原则非常重要,它是判断数据是否存在竞争、 线程是否安全的主要依据,依靠这个原则,我们可以通过几条规则一揽子地解决并发环境下两个操作之间是否可能存在冲突的所有问题。 一、什么是先行发生原则 现在就来看看“先行发生”原则指的是什么。 ,根据程序次序规则,“int i=1”的操作先行发生于“int j=2”,但是“int j=2”的代码完全可能先被处理器执行,这并不影响先行发生原则的正确性,因为我们在这条线程之中没有办法感知到这点。

    3.3K20发布于 2018-09-29
  • 来自专栏冰河技术

    何为Happens-Before原则?这次彻底懂了!

    在正式介绍Happens-Before原则之前,我们先来看一段代码。 其实,答案就是在JDK1.5版本中的Java内存模型中引入了Happens-Before原则。 接下来,我们就结合案例程序来说明Java内存模型中的Happens-Before原则。 【原则三】传递规则 如果A Happens-Before B,并且B Happens-Before C,则A Happens-Before C。 我们结合【原则一】、【原则二】和【原则三】再来看【示例一】程序,此时,我们可以得出如下结论: (1)x = 42 Happens-Before 写变量v = true,符合【原则一】程序次序规则。 (2)写变量v = true Happens-Before 读变量v = true,符合【原则二】volatile变量规则。

    6.9K82发布于 2020-10-29
  • 来自专栏盛开在夏天的太阳

    2.2 指令重排&happens-before 原则 & 内存屏障

    1.2. happens-before 原则 只靠sychronized和volatile关键字来保证原子性、可见性以及有序性,那么编写并发 程序可能会显得十分麻烦,幸运的是,从JDK 5开始,Java 使用新的JSR-133内存模型,提 供了happens-before 原则来辅助保证程序执行的原子性、可见性以及有序性的问题,它是 判断数据是否存在竞争、线程是否安全的依据,happens-before 原则内容如下 1. 程序顺序原则   即在一个线程内必须保证语义串行性,也就是说按照代码顺序执行。 2. Store1; StoreStore; Store2 在store2及其后的写操作执行前,保证store1的写操作已刷新到主内存 LoadStore Load1; LoadStore; Store2

    2.4K20发布于 2020-09-27
  • 来自专栏飞天小牛肉

    JMM 最最最核心的概念:Happens-before 原则

    我想,这两句话就已经足够表明 Happens-before 原则的重要性。 那为什么 Happens-before 被不约而同的称为 JMM 的核心和灵魂呢? 生来如此。 根据根据程序次序规则:1 Happens-before 2;3 Happens-before 4。 根据 volatile 变量规则:2 Happens-before 3。 既然不满足 Happens-before 原则,那我修改下让它满足不就行了。 (Happens-before)于 “int j = 2”,但是,还记得 Happens-before 的第 2 条定义吗? 原则为准。

    1.1K40发布于 2021-05-14
  • 来自专栏韩曙亮的移动开发专栏

    【Java 并发编程】指令重排序规范 ( happens-before 先行发生原则 )

    文章目录 一、指令重排序规范 二、happens-before 先行发生原则 一、指令重排序规范 ---- 指令重排指的是 , 线程中如果两行代码 没有逻辑上的上下关系 , 可以对代码进行 重新排序 ; 规范 : 先行发生原则 ; 二、happens-before 先行发生原则 ---- happens-before 先行发生原则 : A happens-before B , A 先于 B 发生 , 先行发生原则 适用场景 : 在以下场景中 , 不进行指令重排 , 这些先后顺序 , 绝对不能被打乱 , 否则会出现严重线程安全问题 ; 程序次序原则 : 在程序内 , 按照代码书写的执行顺序 , 前面的代码先执行 规则具有传递性 ; 如果 A happens-before B 和 B happens-before C , 则 A happens-before C ; 线程中断 : 调用线程 interrupt( 先行发生原则 " 可以判定两个线程的操作 , 是否有发生冲突的可能 ;

    48410编辑于 2023-03-29
  • 来自专栏技术分享

    深入理解Happens-Before原则:以实例解析并发编程的基石

    Happens-Before原则概述Happens-Before原则是Java内存模型(JMM)中定义的一种偏序关系,用于确定两个操作之间的相对顺序。 Happens-Before原则的实例解析单一线程内的操作在一个线程内,按照程序顺序执行的操作自然满足Happens-Before原则。这是因为单个线程内的操作是顺序执行的,没有并发访问的问题。 这里,锁的释放操作happens-before锁的获取操作。 Happens-Before原则小结Happens-Before原则是并发编程中的基石,它定义了线程间操作顺序和可见性的保证。我们理解并遵循这一原则,就可以编写出正确且可预测的并发程序。 本篇文章到此结束,希望我们开发者们在编写代码时都牢记住这一原则哦!

    77520编辑于 2024-08-09
  • 来自专栏做不甩锅的后端

    多线程基础(四):volatile和可见性问题及happens-before原则

    local is [1] Update value [2] to [2] Get change for INIT [3] local is [2] Update value [3] to [3] Get 4.Happens-Before规则 在《深入理解Java虚拟机》一书中,对Happens-Before原则进行了归纳,主要是以下8个: 1.程序次序规则:在同一线程内部,按照代码顺序,关联代码书写在前面的操作优先发生于书写在后面的操作 如何来理解这些Happens-Before规则呢?Happens-Before并不是说,前一个操作发生在后续操作的前面。而是要表达,前面一个操作的结果对后续操作是可见的。 实际上,Happens-Before对编译器的行为进行了约束,编译器可以根据需要多代码的执行顺序进行优化,但是,编译器的这种优化一定要遵守Happens-Before规则。 5.对Happens-Before的理解 5.1 程序次序规则 需要注意的是,对于这个规则,一jvm在优化的时候,如果书写的代码之间没有任何的依赖关系,那么就不符合这个规则了。

    80120发布于 2020-09-08
  • 来自专栏TopCoder

    happens-before那些事儿

    happens-before原则定义如下: 如果一个操作happens-before另一个操作,那么第一个操作的执行结果将对第二个操作可见,而且第一个操作的执行顺序排在第二个操作之前。 两个操作之间存在happens-before关系,并不意味着一定要按照happens-before原则制定的顺序来执行。 传递规则:体现了happens-before原则具有传递性,即A happens-before B , B happens-before C,那么A happens-before C。 说了这么多happends before原则,那么它是如何实现的呢? 比如volatile规则是volatile产生内存屏障保证了读在写之后进行的。 happen-before原则是JMM中非常重要的原则,它是判断数据是否存在竞争、线程是否安全的主要依据,保证了多线程环境下的可见性。

    68610发布于 2020-11-05
  • 来自专栏陈树义

    什么是 happens-before

    到这里,我们需要明白:happens-before 原则是对 Java 内存模型的简化,让我们更好地写出并发代码。 什么是 happens-beforehappens-before 指的是 Java 内存模型中两项操作的顺序关系。 // 如下操作在同一个线程中执行 int j = 1; int j = 2; 上述代码在同一线程中执行,根据程序执行次序规则,int i = 1; 的操作先行发生于 int j = 2;,但 int j =2 的代码有可能被处理器先执行,因为它们不相互依赖,不影响先行发生原则的正确性。 总结 happens-before 原则一共有 8 条原则,它是对 Java 内存模型规则的简化,帮助编程人员提高编程效率。

    69910编辑于 2022-06-28
  • 深入解析Java内存与运行时机制:Happens-Before原则实战与底层实现

    Happens-Before原则的本质 Happens-Before是JMM中最核心的概念,它定义了操作之间的可见性规则。 实际代码示例:Happens-Before原则的应用 以下是一个展示Happens-Before原则在实际代码中应用的示例: public class HappensBeforeExample { Happens-Before原则的八大规则解析 在Java内存模型(JMM)中,Happens-Before原则是理解多线程程序执行顺序和内存可见性的核心框架。 这对应Happens-Before原则中"解锁先行于后续加锁"的保证。 3. 这正是Happens-Before原则要解决的核心问题。

    50710编辑于 2025-08-27
  • 来自专栏开发笔记

    Chapter 2 :重构的原则

    2,为什么重构? 为了后续的代码维护和修改,易读是重构的核心价值。

    83310发布于 2020-01-22
  • 来自专栏Spark学习技巧

    JMM之Happens-Before规则

    下面我们就说一下什么是Happens-Before规则。 什么是Happens-Before? 在JMM中,在一个线程中,或不同的线程中。 2.监视器锁规则 对一个锁的解锁,Happens-Before于随后对这个锁的加锁; 例子: public class HappensBefore { long num = 4.传递性 A Happens-Before B ,B Happens-Before C,那么 A Happens-Before C 如下图: ? 2⃣️ , 2⃣️ Happens-Before 3⃣️ , 1⃣️ Happens-Before 3⃣️ 。 所以当线程2读取到flag为真的时候,就自然而然的知道了,x的值是42了。 给大家出一个问题,希望大家积极回答!

    77530发布于 2019-06-14
  • 来自专栏JavaQ

    高并发编程-happens-before

    happens-before是Java内存模型中定义的两个操作之间的偏序关系,即如果操作A在操作B之前先发生,那么操作A产生的操作结果,操作B可以观察到,或者说操作A的结果影响到操作B。 笔者认为Java内存模型中的这种与生俱来的原则实现了可见性和顺序性。 happens-before无需任何同步器的协助,只要两个操作之间的关系符合以下列出的这些规则,或者可以由以下这些规则推导出,那么就可以保证它们的顺序性,否则Java虚拟机可以进行任意重排序。

    60620发布于 2018-12-13
  • 来自专栏国产程序员

    面向对象的7种设计原则(2)-接口隔离原则

    或许有的人认为接口隔离原则和单一职责原则很像,但两个原则还是存在着明显的区别。单一职责原则是在业务逻辑上的划分,注重的是职责。接口隔离原则是基于接口设计考虑。 例如一个接口的职责包含10个方法,这10个方法都放在同一接口中,并且提供给多个模块调用,但不同模块需要依赖的方法是不一样的,这时模块为了实现自己的功能就不得不实现一些对其没有意义的方法,这样的设计是不符合接口隔离原则的 接口隔离原则要求"尽量使用多个专门的接口"专门提供给不同的模块。

    1K10发布于 2020-07-13
  • 来自专栏huofo's blog

    设计模式(07)——设计原则2

    KISS原则 Keep It Simple and Stupid 这个原则听起来比较简单,重点是理解什么样的代码是简单的,代码行数少就是简单的代码吗??? 因此如果没办法,在特定场景下,只能采用该算法的实现,那么使用这种复杂逻辑就不是违反 KISS 原则了,因为没办法。 DRY原则 定义 英语解释为:Dont repeat yourself,可以理解为不要写重复的代码,要做好代码的可复用性。 但该规则跟 KISS 原则一样,听起来可能比较简单,但是在实际使用中,却要注重的一个原则。 因为在该原则中,有一个很关键的点,什么样的代码是重复的代码,只是简单的代码一样就是违反该原则了吗? 迪米特原则 定义 迪米特原则是用来指导设计高内聚、低耦合代码的原则,因此我们先看一下什么是高内聚、低耦合。

    48220编辑于 2022-03-17
  • 来自专栏编程

    设计模式六大原则2):里氏替换原则

    SpringCloud实战视频下载 肯定有不少人跟我刚看到这项原则的时候一样,对这个原则的名字充满疑惑。 定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 新功能P由类A的子类B来完成,则子类B在完成新功能P2的同时,有可能会导致原有功能P1发生故障。 解决方案:当使用继承时,遵循里氏替换原则。 里氏替换原则通俗的来讲就是:子类可以扩展父类的功能,但不能改变父类原有的功能。它包含以下4层含义: 1、子类可以实现父类的抽象方法,但不能覆盖父类的非抽象方法。 2、子类中可以增加自己特有的方法。 看上去很不可思议,因为我们会发现在自己编程中常常会违反里氏替换原则,程序照样跑的好好的。所以大家都会产生这样的疑问,假如我非要不遵循里氏替换原则会有什么后果?

    75290发布于 2017-12-29
  • 来自专栏小工匠聊架构

    高并发编程-happens-before

    ---- happens-before规则 7个原则 程序顺序规则:一个线程中的每个操作,happens-before于该线程中的任意后续操作 监视器锁规则:对一个锁的解锁,happens-before ·1 happens-before 2和3 happens-before 4由程序顺序规则产生。 下图是该程序对应的happens-before关系图。 ? 1 happens-before 2由程序顺序规则产生。2 happens-before 4由start()规则产生。 该程序对应的happens-before关系图如下: ? 2 happens-before 4由join()规则产生;4 happens-before 5由程序顺序规则产生。 从上面的分析可以看出,JMM其实是在遵循一个基本原则:只要不改变程序的执行结果(指的是单线程程序和正确同步的多线程程序)编译器和处理器怎么优化都行。 ----

    44130发布于 2021-08-17
  • 来自专栏小樱的经验随笔

    设计模式六大原则2):里氏替换原则

            肯定有不少人跟我刚看到这项原则的时候一样,对这个原则的名字充满疑惑。其实原因就是这项原则最早是在1988年,由麻省理工学院的一位姓里的女士(Barbara Liskov)提出来的。 定义1:如果对每一个类型为 T1的对象 o1,都有类型为 T2 的对象o2,使得以 T1定义的所有程序 P 在所有的对象 o1 都代换成 o2 时,程序 P 的行为没有发生变化,那么类型 T2 是类型 定义2:所有引用基类的地方必须能透明地使用其子类的对象。 问题由来:有一功能P1,由类A完成。现需要将功能P1进行扩展,扩展后的功能为P,其中P由原有功能P1与新功能P2组成。 新功能P由类A的子类B来完成,则子类B在完成新功能P2的同时,有可能会导致原有功能P1发生故障。 解决方案:当使用继承时,遵循里氏替换原则。 看上去很不可思议,因为我们会发现在自己编程中常常会违反里氏替换原则,程序照样跑的好好的。所以大家都会产生这样的疑问,假如我非要不遵循里氏替换原则会有什么后果?        

    68880发布于 2018-04-08
领券