并发编程（二）有序性

最新推荐文章于 2024-05-19 21:34:53 发布
最新推荐文章于 2024-05-19 21:34:53 发布
阅读量302 收藏
点赞数 1
分类专栏： Java多线程 文章标签： java jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fuyuanduan/article/details/127936013
版权

【问题的产生】：

程序真的是按照顺序执行的吗？

/**
 * 本程序跟可见性无关，曾经有同学用单核也发现了这一点
 */

import java.util.concurrent.CountDownLatch;

public class T01_Disorder {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {

        for (long i = 0; i < Long.MAX_VALUE; i++) {
            x = 0;
            y = 0;
            a = 0;
            b = 0;
            CountDownLatch latch = new CountDownLatch(2);

            Thread one = new Thread(new Runnable() {
                public void run() {
                    a = 1;
                    x = b;

                    latch.countDown();
                }

            });

            Thread other = new Thread(new Runnable() {
                public void run() {
                    b = 1;
                    y = a;

                    latch.countDown();
                }
            });
            one.start();
            other.start();
            latch.await();
            String result = "第" + i + "次 (" + x + "," + y + ")";
            if (x == 0 && y == 0) {
                System.err.println(result);
                break;
            }
        }
    }
}

【最终输出】：
在这里插入图片描述
【图解程序 】：
在这里插入图片描述
//上图是8种可能出现的执行情况。你会发现——出现（0，0）的情况就意味着一定是线程内部执行的时候调换了顺序。

【 乱序的原因 】：

//简单说 ， 就是为了提高效率。
【下图】：
第一条CPU指令是去内存读数据，等待数据的返回；
第二条CPU指令是本地寄存器自增。
在这里插入图片描述
【分析】：
//CPU的速度要比内存的速度快100倍。如果必须要按顺序执行的话，在等待返回过程需要大量的等待。

【什么情况下，两条指令可以交换顺序呢？ 】：

如果前后指令之间有依赖关系 ， 后续指令必须依赖前面的指令，那么是无法交换顺序的。——如果前后两条指令不存在依赖关系，则是可以进行交换的。

【 乱序存在的条件 】：

as——if——serial

不影响单线程的最终一致性。

不影响单线程的最终一致性时，各指令可以交换顺序。
【如】：
x=1; y=1。

x=a; y=a。

//上述两组指令都不影响最终结果。（打乱执行顺序的话）

【但如下就不行】：
x=1; x++。

【程序理解可见性和有序性】：

《Java并发编程实践》 中的一个例子。

 package T04_YouXuXing;

public class T02_NoVisibility {
    private static boolean ready = false;
    private static int number;

    private static class ReaderThread extends Thread {
        @Override
        public void run() {
            while (!ready) {
                Thread.yield();
            }
            System.out.println(number);    //这里的打印有可能会是0.
        }
    }

    public static void main(String[] args) throws Exception {
        Thread t = new ReaderThread();
        t.start();
        number = 42;    //没有前后依赖关系。
        ready = true;   //没有前后依赖关系。
        t.join();
    }
}
  • 思考—上述程序存在什么问题吗？
    （1）可见性问题
    ready设置为true后不会马上停止，但也有可能马上停止。
    要在number上加volatile关键字。——保证可见性。
    （2）有序性问题
    number = 42; //没有前后依赖关系。
    ready = true; //没有前后依赖关系。
    //这两个指令有可能第二个先执行——此时就会输出0 ， 因为还没有执行到设置值为42的那一步。

【线程的半初始化状态】：

【对象的创建过程】：

在这里插入图片描述
在这里插入图片描述
0——申请内存；
4——特殊调用，特殊调用了T的init方法即默认的构造方法。
7——建立关联，和t变量建立关联。

【安全性】：
在这里插入图片描述
当我们new出一个对象 ， 里面成员变量m的值是多少呢？——其实是和上一个使用这一块区域的程序有关系（ C语言 ）。
在这里插入图片描述
//Java中int类型的默认值是 0。
在这里插入图片描述
//这一句执行完，m=0 , 这是对象的半初始化状态。
在这里插入图片描述
//执行完这一句指令后——m的值才会变为8。
在这里插入图片描述
t变量和内存区域建立关联。

【 this对象逸出 】：

package T04_YouXuXing;

public class T03_ThisEscape {

    private int num = 8;


    public T03_ThisEscape() {
        new Thread(() -> System.out.println(this.num)      //这里有可能输出中间状态0.
        ).start();
    }

    public static void main(String[] args) throws Exception {
        new T03_ThisEscape();
        System.in.read();      //进入阻塞
    }
}

//——这里是有可能出现问题的。
【 num为何可能输出中间状态呢？ 】：
this存在于局部变量表里面。

//这两条指令是有可能换顺序的。这样就会先建立关联，关联完之后才调用构造方法 ， 结果在调用构造方法的过程当中，新建了一个线程去输出当前的num值——此时因为是先关联的，所以为0 ， 就先输出0了。
在这里插入图片描述
即——先进行了关联 ， 关联完之后再调用的构造方法。

【防止this逸出现象】：

可以在构造方法里NEW线程，但是！！！！！！！————不要让它在那里启动。
什么时候启动？——单独写一个方法。
【 修改程序 】：

package T04_YouXuXing;

public class T03_ThisEscape2 {

    private int num = 8;

    Thread t;

    public T03_ThisEscape2() {
        t = new Thread(() -> System.out.println(this.num) );
    }

    public void start(){
        t.start();
    }

    public static void main(String[] args) throws Exception {
        new T03_ThisEscape2();
        System.in.read();      //进入阻塞
    }
}

【 美团面试题 】：

关于Object o = new Object( )

【1–请解释一下对象的创建过程（半初始化）】：

创建对象是有一个半初始化过程的。Java里半初始化过程是赋默认值的，C++等语言是赋内存上遗留下来的值。

【2–加问DCL与volatile问题（指令重排）】：

DCL单例是否要加volatile ， 这里面主要涉及指令重排序的问题。
volatile有两大作用——线程可见&禁止重排。as_if_serial这种机制是为了提高利用率。
在这里插入图片描述
单线程中as_if_serial结果幂等 ， 执行指令可以随意排序。——但是，这种程序一旦到了多线程中就会出现问题！！！！！！
如果不想让其排序的话 ， 怎么办？——使用volatile可以禁止重排～～～！ ！ ！

【DCL】：

饿汉式单例代码：

package T04_YouXuXing.T05_singleton;

/*
饿汉式
类加载到内存之后，就实例化一个单例，JVM保证线程安全；
唯一缺点————不管用到与否，类装载时就完成实例化；
* */
public class Mgr01 {
    private static final Mgr01 INSTANCE = new Mgr01();
    private Mgr01(){};
    public static Mgr01 getInstance(){ return INSTANCE; }

    public void m(){
        System.out.println("m");
    }

    public static void main(String[] args){
        Mgr01 m1 = Mgr01.getInstance();
        Mgr01 m2 = Mgr01.getInstance();
        System.out.println(m1==m2);
    }
}

【最终输出】：
True
懒汉式代码：

package T04_YouXuXing.T05_singleton;

/*
* 懒汉式写法
* 【缺点】：多线程访问的时候，你不能够保证一致性，你不能够保证NEW出来的都是同一个对象；
* */
public class Mgr03 {
    private static Mgr03 INSTANCE;

    private Mgr03(){ }

    public static Mgr03 getInstance(){
        if (INSTANCE == null){           //两个线程接连判断都为NULL（还没来得及NEW出来），这时就会新建两个。
            try{
                Thread.sleep(1);   //让更多的线程进入IF循环来新建对象就能更清晰的展示问题。
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            INSTANCE = new Mgr03();
        }
        return INSTANCE;
    }

    public void m(){
        System.out.println(" m ");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(
                    ()-> System.out.println(  Mgr03.getInstance().hashCode()  )
            ).start();
        }
    }
}

【最终输出】：
在这里插入图片描述
【修正程序】：
//只在上述程序的基础上加synchronized

    public static synchronized Mgr03_02 getInstance(){    
        if (INSTANCE == null){           //两个线程接连判断都为NULL（还没来得及NEW出来），这时就会新建两个。
            try{
                Thread.sleep(1);   //让更多的线程进入IF循环来新建对象就能更清晰的展示问题。
            }catch (InterruptedException e){
                e.printStackTrace();
            }
            INSTANCE = new Mgr03_02();
        }
        return INSTANCE;
    }

在这里插入图片描述
//但是仍然有问题——锁的粒度太粗了～ ～ ～ ！ ！ ！
【继续修改】：

    public static  Mgr03_03 getInstance(){

        //业务代码
        
        if (INSTANCE == null){           //两个线程接连判断都为NULL（还没来得及NEW出来），这时就会新建两个。
            //妄图通过缩减同步代码块的方式提高效率，然后不可行。
            synchronized(Mgr03_03.class) {
                try {
                    Thread.sleep(1);   //让更多的线程进入IF循环来新建对象就能更清晰的展示问题。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new Mgr03_03();
            }
        }
        return INSTANCE;
    }

在这里插入图片描述
//还是无法保证一致性～～～！！！！！！前一个线程刚释放锁，后一个线程就拿到锁了，然后就立即NEW了一个对象。
【DCL机制】：

package T04_YouXuXing.T05_singleton;

// DCL  Double Check Lock
public class Mgr06 {
    private static volatile Mgr06 INSTANCE;  //JIT

    private Mgr06(){}

    public static Mgr06 getInstance(){
        //业务代码省略

        if (INSTANCE == null){    //Double  Check  Lock

            synchronized(Mgr06.class) {

                if (INSTANCE==null) {
                    try {
                        Thread.sleep(1);   //让更多的线程进入IF循环来新建对象就能更清晰的展示问题。
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }
    public void m(){
        System.out.println(" m ");
    }

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(
                    ()-> System.out.println(  Mgr06.getInstance().hashCode()  )
            ).start();
        }
    }
}

【提高效率的细节】：

         if (INSTANCE == null){    //Double  Check  Lock——————这一行可以提高效率
            synchronized(Mgr06.class) {
                if (INSTANCE==null) {

第一个判断INSTANCE是否==null 是非常有必要的，如果去掉的话，那么所有的线程二话不说一上来全都在抢锁，竞争锁消耗的资源是非常高的。

【DCL和volatile的问题】：

【结论】：
DCL必须要加上volatile

private static volatile Mgr06 INSTANCE;  //JIT

【Q】：不加的话会怎么样呢？？？
在这里插入图片描述
在这里插入图片描述
//第一个线程进来，刚刚完成半初始化，这个时候发生了指令重排序。
在这里插入图片描述
//刚执行完连接的时候，外面就有一个线程进入了IF判断！！！（这个时候虽然没有完成初始化，但是已经赋上了默认值，外面的线程就会拿到半初始化状态的对象！！！）

【总结】：
在这里插入图片描述
thread1刚刚执行完连接那一步，这个时候thread2进入了IF判断，拿到刚半初始化完（没有完全初始化，没有调用构造方法）的对象。

【3–对象在内存中的存储布局（对象与数组的存储不同）】：

普通对象

在这里插入图片描述
mrakword——标记字。
class pointer——当你new出一个对象来 ， 你这个对象是属于哪一个class的呢？ ？ ？
padding——64位虚拟机的话，就是8字节对齐（ 将前面三块markword、class pointer、instance data补到能被8整除的字节 ），就和用集装箱装东西一样，用8字节比较规整。
【UseCompressedClassPointers】：
使用压缩类指针；
【UseCompressedOops】：
OrdinaryObjectPointer
使用压缩的普通对象指针。

【类指针】：

在这里插入图片描述
//这个类指针默认是启动压缩的 ， 压缩完是4byte 。

【普通对象指针】：

String s , s就是一个指针，默认这两个的压缩都是开启的。

【数组类型】：

在这里插入图片描述
//唯一区别是多了4字节的数组长度；

【4–对象头具体包括什么（markword classpointer）synchronized锁信息】：

对象头主要包括markword 和 class_pointer两部分，class pointer是默认开压缩的4个字节 ， 如果不开压缩就是8个字节。

【 研究一个对象内存布局的工具 】：
org.openjdk.jol

全称——JavaObjectLayout
在这里插入图片描述
在这里插入图片描述
//parseInstance——解析这个对象 ， 然后变成可以打印的。
在这里插入图片描述
Instance size:16 bytes ———一共有16个字节构成。
在这里插入图片描述
//指向Object.class
在这里插入图片描述
空间的丢失4个字节。空间丢失就是为了补齐的意思。

【多加一个变量然后进行测试】：
在这里插入图片描述
markword ——8 ；
classpointer——4；
instance data——4；
8+4+4=16 ， 所以已经是8的倍数了 ， 没有必要再去补齐。
在这里插入图片描述
在这里插入图片描述
//最后的4个字节是m变量。

【再进行一例测试】：
在这里插入图片描述
在这里插入图片描述
//最后补了4个字节。

【markword中主要包括什么呢 ？ 】：

最主要的是包含锁信息 ， 其他的都是次要的。
锁信息、GC信息、IdentityHashCode 。

【5–对象怎么定位？（直接 间接）】

句柄方式
直接指针
在这里插入图片描述
在这里插入图片描述
//定位就是指——如何通过 t 来找到 T 。

【6–对象怎么分配？（栈上—线程本地—Eden—Old ）】：

首先会尝试在栈上分配 ， 如果能在栈上分配就分配在栈上；分配在栈上的好处就是——一旦弹出，它的生命周期就结束了。
在这里插入图片描述
【 什么样的对象能够在栈上分配呢 ？ 】：
逃逸分析；
标量替换；
在这里插入图片描述

如果个儿超级大——扔到老年代。
如果不大不小——往TLAB中分配。TLAB全称是——Thread Local Allocation Buffer( 线程本地分配缓冲区 ) ， E代表伊甸区 ，AGE是年龄 。
【解释线程本地分配】：
当我们往一个内存区域里NEW对象的时候 ， 总是要分配空间的。多个线程往同一个内存空间里分配对象的时候，必须要经过同步。有线程的协调，就会有效率上的损失。
【线程本地分配缓冲区】：
当一个线程启动的时候 ， 为这个线程在伊甸区里分配一个小小的空间，这个空间是线程所独享的 ， 如果线程NEW了任何对象，就往对应的空间里扔，往自己的兜里扔东西的话，就不需要进行争抢了。

【7–Object o = new Object( ) 在内存中占用多少字节？ 】：

1）有没有压缩class pointer 。
2) 有没有压缩oops 。
3) 看内存是不是32G以下或者以上 。

【8–为什么hotspot不使用C++对象来代表Java对象？】：

因为C++中有一个 vtbl 的指针 ， 它指向的是虚方法表 ， 虚方法表是用来实现多态的。Java中的是oop-class二元机制。

【9–Class对象是在堆还是在方法区？】：

在这里插入图片描述
O.class是给反射用的；
OOM溢出实际上是方法区里溢出了：
在这里插入图片描述

【阶段小结】：

在这里插入图片描述

【happens—before原则】：

【CPU级别】：
只要你不影响单线程的一致性，指令随便换。

【JVM级别】：
对Java的哪些指令不可以互换做了一些规定。

【CPU用屏障指令阻止乱序】：

【CPU汇编指令一级】：

内存屏障

所谓的内存屏障就是一条特殊的指令 ，当看到这种指令的时候，前面的指令和后面的指令不可以换顺序。
内存屏障是特殊指令：看到这种指令，前面的必须执行完，后面的才能执行

intel : lfence（读） sfence（写） mfence（读和写）(CPU特有指令)

//我们的JVM并不是靠这种底层指令来实现的 ， 它并没有去针对不同的CPU从而使用不同CPU的内存屏障指令，不是。

【JVM要求实现的四种屏障】：

【JVM层级的内存屏障】：

在这里插入图片描述
所有要求实现JVM的Java虚拟机 ， 都应该实现自己的JVM级别的内存屏障 ， 你的JVM实现应该有这四条的屏障，不论你底层采用什么汇编语言来实现。JVM层级必须得有能实现这四个屏障的效果。
Load叫 “读” ， Store叫 “写”。
【LoadLoad】：
在这里插入图片描述
//两条读之令中间夹了一个指令——LoadLoad , 那么上面的Load指令就不能和下面的Load指令交换顺序。其他的三个屏障可以类比理解。

【用volatile禁止指令重排】：

在这里插入图片描述
//StoreStoreBarrier——在我写之前，以前所有的写指令必须先完成，别人写完我才能写。
后面还一个指令：
//StoreLoadBarrier——等我写完别人才能读。
在这里插入图片描述
LoadLoadBarrier——等我读完，别人才能读；
LoadStoreBarrier——等我读完，别人才能写。

【volatile在hotspot中的实现】：

volatile的底层实现

volatile修饰的内存，不可以重排序，对volatile修饰变量的读写访问，都不可以换顺序

1: volatile i

2: ACC_VOLATILE

3: JVM的内存屏障

​ 屏障两边的指令不可以重排！保障有序！

​ happends-before

​ as - if - serial

4：hotspot实现

bytecodeinterpreter.cpp

int field_offset = cache->f2_as_index();
          if (cache->is_volatile()) {
            if (support_IRIW_for_not_multiple_copy_atomic_cpu) {
              OrderAccess::fence();
            }

orderaccess_linux_x86.inline.hpp

inline void OrderAccess::fence() {
  if (os::is_MP()) {   //如果操作系统是多核的。
    // always use locked addl since mfence is sometimes expensive
#ifdef AMD64
    __asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");    //这条指令的核心是lock而非后面的add。
#else
    __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
#endif
  }
}

LOCK 用于在多处理器中执行指令时对共享内存的独占使用。
它的作用是能够将当前处理器对应缓存的内容刷新到内存，并使其他处理器对应的缓存失效。
另外还提供了有序的指令无法越过这个内存屏障的作用。
lock指令是比较特殊的，后面必须要跟其他的指令——表示当我执行后面的指令的时候，对总线/缓存 进行锁定，后面的这个指令不能是空指令，不能是NOP ， addl $0,0(%%rsp)即给寄存器加了一个0，相当于是空操作。
在这里插入图片描述
//两颗CPU访问同一块内存的话 ， 我会将总线进行锁定或者我会把对应的缓存行进行锁定（一个叫总线锁 ，一个叫缓存锁）。

无量寂空
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Java并发编程实战 02Java如何解决可见性和有序性问题
12-21
摘要 在上一篇文章当中，讲到了CPU缓存导致可见性、线程切换导致了原子性、编译优化导致了有序性问题。那么这篇文章就先解决其中的可见性和有序性问题，引出了今天的主角：Java内存模型（面试并发的时候会经常考核到） 什么是Java内存模型？ 现在知道了CPU缓存导致可见性、编译优化导致了有序性问题，那么最简单的方式就是直接禁用CPU缓存和编译优化。但是这样做我们的性能可就要爆炸了~。我们应该按需禁用。 Java内存模型是有一个很复杂的规范，但是站在程序员的角度上可以理解为：Java内存模型规范了JVM如何提供按需禁用缓存和编译优化的方法。 具体包括 volatile、synchronized、fi
java并发编程(4) 有序性-指令重排序
Jwasx的博客
01-29 1499
文章目录前言1. 概念2. 数据依赖性3. as-if-serial1. 概念和理解2. 例子 前言 这一系列资料基于黑马的视频：java并发编程，这篇文章中介绍指令重排序以及如何解决这个问题。同时参考了《Java并发编程这本书》，程序员必备 1. 概念 重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段。比如下面的一段代码： //重排序前 int i = 0; int j = 1; //重排序后 int j = 1; int i = 0; 这段赋值的代码重排序之后可能顺序
两个例子详解并发编程的可见性问题和有序性问题，通过volatile保证可见性和有序性以及volatile的底层原理——缓存一致性协议MESI和内存屏障禁止指令重排
走过路过不要错过
05-17 229
1. 未加volatile关键字，由于缓存不一致性导致线程间数据交互失败 public class Test { private static int INIT_VAL = 0; private static final Integer MAX_VAL = 5; public static void main(String[] args) { new Thread(){ @Override public void
并发编程中的原子性，可见性，有序性问题
小威的博客
10-24 4378
祝诸佬们1024程序员节快乐！！！本章节主要讲解了并发编程中的原子性，可见性，有序性问题，感兴趣的大佬可以前来围观哦~
【面试：并发篇28：volatile】有序性
m0_71229547的博客
07-27 178
什么是有序性在不改变程序结果的前提下指令可以在各个阶段通过重排序和组合来实现指令级并行。注意重排序指令不能影响结果为什么这样做cpu处理过程在cpu处理一个指令是包含一系列工序的，包含了取指译码地址生成执行回写，这五步但是这五步之间是可以交错运行的，也就是一个指令译码的时候另一个指令可以取指。例子1x=a;y=b;这样的执行效率显然更加的快，且在语句之间没有关系时执行顺序可以随便，也就是可能先执行y=b再执行x=a，不影响结果例子2x=a;y=b;总结。...
深入理解并发可见性、有序性、原子性与JMM内存模型
so1ucky的博客
08-09 32
Java中的volatile关键字可以保证多线程操作共享变量的可见性以及禁止指令重排序，synchronized关键字不仅保证可见性，同时也保证了原子性（互斥性）。在更底层，JMM通过内存屏障来实现内存的可见性以及禁止重排序。为了程序员的方便理解，提出了happens-before，它更加的简单易懂，从而避免了程序员为了理解内存可见性而去学习复杂的重排序规则以及这些规则的具体实现方法。
多线程的再学习
szy2333的博客
09-28 292
多线程的进阶学习CAS 本文主要是跟着B站马士兵老师的课学习做的笔记，老师的课真的值得一看！！！ 课程链接：https://www.bilibili.com/video/BV1xK4y1C7aT?from=search&seid=5058132445119285717 CAS CAS，即 compare and swap，意思就是先比较后交换：先拿到当前的值A并计算结果值V，然后拿到当前的新值N，在改变新值之前，先比较A和N值是否一致，如果一致，则更新值为V，如果不一致，那就重新执行这个步骤。流程图
线程安全问题及关键字synchronized,volatile
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
07-31 699
非原子性操作是指一个操作被分成多个指令,由于操作系统的调度,导致有些指令并没有被执行,最终影响结果。
【Java并发编程】Java多线程（五）：关于线程的几个问题
A minor
09-16 1601
1.子线程 1 去等待子线程 2 执行完成之后才能执行，如何去实现？ 答：这里考察的就是 Thread.join 方法，我们可以这么做： @Test public void testJoin2() throws Exception { // 线程2 Thread thread2 = new Thread(new Runnable() { public void run() {...} }); // 线程1 Thread thread1 = new Thread(new Runna
并发编程三要素详解
weixin_38568503的博客
03-08 872
目录并发编程三要素：并发编程三要素总结并发编程三要素详解：原子性：可见性：有序性：volatile关键字的两层语义：出现线程安全问题的原因：解决办法： 并发编程三要素： 并发编程三要素总结 并发编程三要素（线程的安全性问题体现在）： 原子性：原子，即一个不可再被分割的颗粒。 原子性指的是一个或多个操作要么全部执行成功,要么全部执行失败。 原子性（Atomicity）：在一次或多次操作中，要么所有的操作都执行并且不会受其他因素干扰而中断，要么所有的操作都不执行 可见性：一个线程对共享变量的修改,其他线程
java并发编程理论基础精讲
08-09
本资源为您提供了关于 Java ...volatile 关键字： 解释 volatile 关键字的作用，探讨如何使用 volatile 实现线程间的可见性和有序性。 通过这份资源，将为您提供实用的指导，帮助您构建更稳定、可靠的多线程应用程序。
汪文君高并发编程实战视频资源下载.txt
08-08
│ 高并发编程第二阶段08讲、并发编程的三个重要概念，原子性，可见性，有序性.mp4 │ 高并发编程第二阶段09讲、指令重排序，happens-before规则精讲.mp4 │ 高并发编程第二阶段10讲、volatile关键字深入详解.mp4...
并发编程基础知识，java内存模型及多线程、volatile
04-29
● JMM的关键技术点都是围绕着多线程的原⼦性、可⻅性和有序性来创建的。所以，下⾯我们来⼀⼀ 介绍这三种特性。原子性、可见性、有序性。 正常情况下，如果我们不使⽤volatile，那么每条线程都会有⾃⼰的缓存，当...
jar包增量更新分析
junlaiyan的专栏
05-16 396
借助jdeps分析出jar包的增量文件
docker中安装jenkins，并在node和cloud上跑通基于源码控制SCM的pipeline
qq_29022265的博客
05-19 1103
从安装jenkins到创建jenkins的node和cloud，最后再将scm和FreeStyle两种流水线跑通。
java实现拼图小游戏
monkey108的博客
05-16 716
本文主要提供用java实现的拼图小游戏源代码。
分布式锁2-Zookeeper分布式锁实战
最新发布
qq_43676797的博客
05-19 238
使用curator操作Zookeeper进行实战；：Apache Curator包含一套高级API框架和工具类，它 是Apache ZooKeeper 的Java 客户端库。
命令执行漏洞（二）
XLbb的博客
05-15 1021
POST方法，S2-045-bypass-2漏洞存在！,程序更改为S2-045-bypass-2漏洞测试模式, 响应码: 200。POST方法，S2-046-bypass漏洞存在！POST方法，S2-045-bypass漏洞存在！POST方法，S2-046-1漏洞存在！POST方法，S2-046-2漏洞存在！POST方法，S2-046-3漏洞存在！POST方法，S2-045-1漏洞存在！POST方法，S2-045-3漏洞存在！POST方法，S2-045-2漏洞存在！POST方法，S2-045-4漏洞存在！
java并发中有序性是什么意思
05-12
在Java并发编程中，有序性指的是指令执行的顺序。在单线程环境下，程序的指令是按照代码编写的顺序依次执行的，但在多线程环境中，由于线程之间的交替执行，指令的执行顺序会变得不确定。 Java提供了一些机制来保证...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值