JUC面试（二）——JUC&JMM&volatile 2.0

最新推荐文章于 2023-12-13 15:09:02 发布
最新推荐文章于 2023-12-13 15:09:02 发布
阅读量489 收藏
点赞数 3
分类专栏： java 面试 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43409401/article/details/128688475
版权
java 同时被 2 个专栏收录
91 篇文章 7 订阅
订阅专栏
面试
39 篇文章 1 订阅
订阅专栏

JUC&JMM

JMM

不保证原子性

各个线程对主内存中共享变量的操作都是各个线程各自拷贝到自己的工作内存进行操作后在写回到主内存中的。

这就可能存在一个线程AAA修改了共享变量X的值，但是还未写入主内存时，另外一个线程BBB又对主内存中同一共享变量X进行操作，但此时A线程工作内存中共享变量X对线程B来说是不可见，这种工作内存与主内存同步延迟现象就造成了可见性问题。

线程AAA写入主内存，lock住，BBB线程赋值完，没有抢到lock，准备写入，但是线程AAA写完主内存后触发了总线通知机制，可见到其它工作内存，这时BBB线程也接收到而无效工作内存中的变量值，这时BBB线程的赋值操作失效了。

原子性：不可分割，完整性，也就是说某个线程正在做某个具体业务时，中间不可以被加塞或者被分割，需要具体完成，要么同时成功，要么同时失败。数据库也经常提到事务具备原子性。举个简单例子，对于变量x，进行加1，然后取到值，这一个过程尽管简单，但是却不具备原子性，因为我们要先读取x，之后进行计算，然后重新写入。

原子性是指一个操作是不可中断的。即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰。

具有原子性的量，同一时刻只能有一个线程来对它进行操作

原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型）这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++；这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。

举个栗子：

一个变量i被volatile修饰，两个线程想对这个变量修改，都对其进行自增操作也就是i++，i++的过程可以分为三步，首先获取i的值，其次对i的值进行加1，最后将得到的新值写会到缓存中。
线程A首先得到了i的初始值100，但是还没来得及修改，就阻塞了，这时线程B开始了，它也得到了i的值，由于i的值未被修改，即使是被volatile修饰，主存的变量还没变化，那么线程B得到的值也是100，之后对其进行加1操作，得到101后，将新值写入到缓存中，再刷入主存中。根据可见性的原则，这个主存的值可以被其他线程可见。
问题来了，线程A已经读取到了i的值为100，也就是说读取的这个原子操作已经结束了，所以这个可见性来的有点晚，线程A阻塞结束后，继续将100这个值加1，得到101，再将值写到缓存，最后刷入主存，所以即便是volatile具有可见性，也不能保证对它修饰的变量具有原子性。

代码测试

为了测试volatile是否保证原子性，我们创建了20个线程，然后每个线程分别循环1000次，来调用number++的方法

最后通过 Thread.activeCount()，来感知20个线程是否执行完毕，这里判断线程数是否大于2，为什么是2？因为默认是有两个线程的，一个main线程，一个gc线程

// 需要等待上面20个线程都计算完成后，在用main线程取得最终的结果值
while(Thread.activeCount() > 2) {
    // yield表示不执行
    Thread.yield();
}

然后在线程执行完毕后，我们在查看number的值，假设volatile保证原子性的话，那么最后输出的值应该是

20 * 1000 = 20000

代码如下：

/**
 * Volatile Java虚拟机提供的轻量级同步机制
 *
 * 可见性（及时通知）
 * 不保证原子性
 * 禁止指令重排
 *
 * @author: 陌溪
 * @create: 2020-03-09-15:58
 */

/**
 * 假设是主物理内存
 */
class MyData2 {

    /**
     * volatile 修饰的关键字，是为了增加 主线程和线程之间的可见性，只要有一个线程修改了内存中的值，其它线程也能马上感知
     */
    volatile int number = 0;

    public void addTo60() {
        this.number = 60;
    }

    synchronized锁上，一次只能一个线程访问，可解决原子性问题
    /**
     * 注意，此时number 前面是加了volatile修饰
     */
    public /*synchronized*/ void addPlusPlus() {
        number ++;
    }
}

/**
 * 验证volatile的可见性
 * 1、 假设int number = 0， number变量之前没有添加volatile关键字修饰
 * 2、添加了volatile，可以解决可见性问题
 *
 * 验证volatile不保证原子性
 * 1、原子性指的是什么意思？
 */
public class VolatileDemo2 {

    public static void main(String[] args) {

        MyData2 myData = new MyData2();

        // 创建10个线程，线程里面进行1000次循环
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                // 里面
                for (int j = 0; j < 1000; j++) {
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }

        // 需要等待上面20个线程都计算完成后，在用main线程取得最终的结果值
        // 这里判断线程数是否大于2，为什么是2？因为默认是有两个线程的，一个main线程，一个gc线程
        while(Thread.activeCount() > 2) {
            // yield表示不执行
            Thread.yield();
        }

        // 查看最终的值
        // 假设volatile保证原子性，那么输出的值应该为：  20 * 1000 = 20000
        System.out.println(Thread.currentThread().getName() + "\t finally number value: " + myData.number);

    }
}

最终结果我们会发现，number输出的值并没有20000，而且是每次运行的结果都不一致的，这说明了volatile修饰的变量不保证原子性。

在这里插入图片描述

但也有可能出现20000，速度快的话

在这里插入图片描述

原因分析

在这里插入图片描述

各自线程在写入主内存的时候，可能同时多个线程写入，其中一个写入后，未及时通知，另外的线程被唤醒，按原来的变量修改写入，直接出现了数据的丢失，而引起的数值缺失的问题

下面我们将一个简单的number++操作，转换为字节码文件一探究竟

public class T1 {
    volatile int n = 0;
    public void add() {
        n++;
    }
}

转换后的字节码文件

public class com.moxi.interview.study.thread.T1 {
  volatile int n;

  public com.moxi.interview.study.thread.T1();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_0
       6: putfield      #2                  // Field n:I
       9: return

  public void add();
    Code:
       0: aload_0
       1: dup
       2: getfield      #2                  // Field n:I
       5: iconst_1
       6: iadd
       7: putfield      #2                  // Field n:I
      10: return
}

这里查看字节码的操作，是用到了IDEA的javap命令

我们首先，使用IDEA提供的External Tools，来扩展javap命令

在这里插入图片描述

完成上述操作后，我们在需要查看字节码的文件下，右键选择 External Tools即可

在这里插入图片描述

如果出现了找不到指定类，那是因为我们创建的是spring boot的maven项目，我们之前需要执行mvn package命令，进行打包操作，将其编译成class文件

可以看字节码指令对照表，方便我们进行阅读

下面我们就针对 add() 这个方法的字节码文件进行分析

  public void add();
    Code:
       0: aload_0
       1: dup
       2: getfield      #2    // Field n:I
       5: iconst_1
       6: iadd
       7: putfield      #2    // Field n:I
      10: return

我们能够发现 n++这条命令，被拆分成了3个指令

  • 执行getfield 从主内存拿到原始n
  • 执行iadd 进行加1操作
  • 执行putfileld 把累加后的值写回主内存

假设我们没有加 synchronized那么第一步就可能存在着，三个线程同时通过getfield命令，拿到主存中的 n值，然后三个线程，各自在自己的工作内存中进行加1操作，但他们并发进行 iadd 命令的时候，因为只能一个进行写，所以其它操作会被挂起，假设1线程，先进行了写操作，在写完后，volatile的可见性，应该需要告诉其它两个线程，主内存的值已经被修改了，但是因为太快了，其它两个线程，陆续执行 iadd命令，进行写入操作，这就造成了其他线程没有接受到主内存n的改变，从而覆盖了原来的值，出现写丢失，这样也就让最终的结果少于20000

如何解决

因此这也说明，在多线程环境下 number ++ 在多线程环境下是非线程安全的，解决的方法有哪些呢？

  • 在方法上加入 synchronized(xin k naɪ zd)，同步锁，排队，一次只能一个线程访问该方法。
    public synchronized void addPlusPlus() {
        number ++;
    }

运行结果：

在这里插入图片描述

我们能够发现引入synchronized关键字后，保证了该方法每次只能够一个线程进行访问和操作，最终输出的结果也就为20000

其它解决方法

上面的方法引入synchronized，虽然能够保证原子性，但是为了解决number++，而引入重量级的同步机制，有种杀鸡焉用牛刀

除了引用synchronized关键字外，还可以使用JUC下面的原子包装类，即刚刚的int类型的number，可以使用AtomicInteger来代替

    /**
     *  创建一个原子Integer包装类，默认为0
     *  参数传值
     */
    AtomicInteger atomicInteger = new AtomicInteger();

    public void addAtomic() {
        // 相当于 atomicInter ++
        atomicInteger.getAndIncrement();
    }

然后同理，继续刚刚的操作

        // 创建10个线程，线程里面进行1000次循环
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                // 里面
                for (int j = 0; j < 1000; j++) {
                    myData.addPlusPlus();
                    myData.addAtomic();
                }
            }, String.valueOf(i)).start();
        }

最后输出

      // 假设volatile保证原子性，那么输出的值应该为：  20 * 1000 = 20000
        System.out.println(Thread.currentThread().getName() + "\t finally number value: " + myData.number);
        System.out.println(Thread.currentThread().getName() + "\t finally atomicNumber value: " + myData.atomicInteger);

下面的结果，第一个是普通int，一个是使用了原子包装类AtomicInteger

在这里插入图片描述

字节码指令表

为了方便阅读JVM字节码文件，整理了一份字节码指令表

引用：https://segmentfault.com/a/1190000008722128

字节码助记符指令含义
0x00nopNone
0x01aconst_null将null推送至栈顶
0x02iconst_m1将int型-1推送至栈顶
0x03iconst_0将int型0推送至栈顶
0x04iconst_1将int型1推送至栈顶
0x05iconst_2将int型2推送至栈顶
0x06iconst_3将int型3推送至栈顶
0x07iconst_4将int型4推送至栈顶
0x08iconst_5将int型5推送至栈顶
0x09lconst_0将long型0推送至栈顶
0x0alconst_1将long型1推送至栈顶
0x0bfconst_0将float型0推送至栈顶
0x0cfconst_1将float型1推送至栈顶
0x0dfconst_2将float型2推送至栈顶
0x0edconst_0将double型0推送至栈顶
0x0fdconst_1将double型1推送至栈顶
0x10bipush将单字节的常量值(-128~127)推送至栈顶
0x11sipush将一个短整型常量(-32768~32767)推送至栈顶
0x12ldc将int,float或String型常量值从常量池中推送至栈顶
0x13ldc_w将int,float或String型常量值从常量池中推送至栈顶(宽索引)
0x14ldc2_w将long或double型常量值从常量池中推送至栈顶(宽索引)
0x15iload将指定的int型本地变量推送至栈顶
0x16lload将指定的long型本地变量推送至栈顶
0x17fload将指定的float型本地变量推送至栈顶
0x18dload将指定的double型本地变量推送至栈顶
0x19aload将指定的引用类型本地变量推送至栈顶
0x1aiload_0将第一个int型本地变量推送至栈顶
0x1biload_1将第二个int型本地变量推送至栈顶
0x1ciload_2将第三个int型本地变量推送至栈顶
0x1diload_3将第四个int型本地变量推送至栈顶
0x1elload_0将第一个long型本地变量推送至栈顶
0x1flload_1将第二个long型本地变量推送至栈顶
0x20lload_2将第三个long型本地变量推送至栈顶
0x21lload_3将第四个long型本地变量推送至栈顶
0x22fload_0将第一个float型本地变量推送至栈顶
0x23fload_1将第二个float型本地变量推送至栈顶
0x24fload_2将第三个float型本地变量推送至栈顶
0x25fload_3将第四个float型本地变量推送至栈顶
0x26dload_0将第一个double型本地变量推送至栈顶
0x27dload_1将第二个double型本地变量推送至栈顶
0x28dload_2将第三个double型本地变量推送至栈顶
0x29dload_3将第四个double型本地变量推送至栈顶
0x2aaload_0将第一个引用类型本地变量推送至栈顶
0x2baload_1将第二个引用类型本地变量推送至栈顶
0x2caload_2将第三个引用类型本地变量推送至栈顶
0x2daload_3将第四个引用类型本地变量推送至栈顶
0x2eiaload将int型数组指定索引的值推送至栈顶
0x2flaload将long型数组指定索引的值推送至栈顶
0x30faload将float型数组指定索引的值推送至栈顶
0x31daload将double型数组指定索引的值推送至栈顶
0x32aaload将引用类型数组指定索引的值推送至栈顶
0x33baload将boolean或byte型数组指定索引的值推送至栈顶
0x34caload将char型数组指定索引的值推送至栈顶
0x35saload将short型数组指定索引的值推送至栈顶
0x36istore将栈顶int型数值存入指定本地变量
0x37lstore将栈顶long型数值存入指定本地变量
0x38fstore将栈顶float型数值存入指定本地变量
0x39dstore将栈顶double型数值存入指定本地变量
0x3aastore将栈顶引用类型数值存入指定本地变量
0x3bistore_0将栈顶int型数值存入第一个本地变量
0x3cistore_1将栈顶int型数值存入第二个本地变量
0x3distore_2将栈顶int型数值存入第三个本地变量
0x3eistore_3将栈顶int型数值存入第四个本地变量
0x3flstore_0将栈顶long型数值存入第一个本地变量
0x40lstore_1将栈顶long型数值存入第二个本地变量
0x41lstore_2将栈顶long型数值存入第三个本地变量
0x42lstore_3将栈顶long型数值存入第四个本地变量
0x43fstore_0将栈顶float型数值存入第一个本地变量
0x44fstore_1将栈顶float型数值存入第二个本地变量
0x45fstore_2将栈顶float型数值存入第三个本地变量
0x46fstore_3将栈顶float型数值存入第四个本地变量
0x47dstore_0将栈顶double型数值存入第一个本地变量
0x48dstore_1将栈顶double型数值存入第二个本地变量
0x49dstore_2将栈顶double型数值存入第三个本地变量
0x4adstore_3将栈顶double型数值存入第四个本地变量
0x4bastore_0将栈顶引用型数值存入第一个本地变量
0x4castore_1将栈顶引用型数值存入第二个本地变量
0x4dastore_2将栈顶引用型数值存入第三个本地变量
0x4eastore_3将栈顶引用型数值存入第四个本地变量
0x4fiastore将栈顶int型数值存入指定数组的指定索引位置
0x50lastore将栈顶long型数值存入指定数组的指定索引位置
0x51fastore将栈顶float型数值存入指定数组的指定索引位置
0x52dastore将栈顶double型数值存入指定数组的指定索引位置
0x53aastore将栈顶引用型数值存入指定数组的指定索引位置
0x54bastore将栈顶boolean或byte型数值存入指定数组的指定索引位置
0x55castore将栈顶char型数值存入指定数组的指定索引位置
0x56sastore将栈顶short型数值存入指定数组的指定索引位置
0x57pop将栈顶数值弹出(数值不能是long或double类型的)
0x58pop2将栈顶的一个(对于非long或double类型)或两个数值(对于非long或double的其他类型)弹出
0x59dup复制栈顶数值并将复制值压入栈顶
0x5adup_x1复制栈顶数值并将两个复制值压入栈顶
0x5bdup_x2复制栈顶数值并将三个(或两个)复制值压入栈顶
0x5cdup2复制栈顶一个(对于long或double类型)或两个(对于非long或double的其他类型)数值并将复制值压入栈顶
0x5ddup2_x1dup_x1指令的双倍版本
0x5edup2_x2dup_x2指令的双倍版本
0x5fswap将栈顶最顶端的两个数值互换(数值不能是long或double类型)
0x60iadd将栈顶两int型数值相加并将结果压入栈顶
0x61ladd将栈顶两long型数值相加并将结果压入栈顶
0x62fadd将栈顶两float型数值相加并将结果压入栈顶
0x63dadd将栈顶两double型数值相加并将结果压入栈顶
0x64isub将栈顶两int型数值相减并将结果压入栈顶
0x65lsub将栈顶两long型数值相减并将结果压入栈顶
0x66fsub将栈顶两float型数值相减并将结果压入栈顶
0x67dsub将栈顶两double型数值相减并将结果压入栈顶
0x68imul将栈顶两int型数值相乘并将结果压入栈顶
0x69lmul将栈顶两long型数值相乘并将结果压入栈顶
0x6afmul将栈顶两float型数值相乘并将结果压入栈顶
0x6bdmul将栈顶两double型数值相乘并将结果压入栈顶
0x6cidiv将栈顶两int型数值相除并将结果压入栈顶
0x6dldiv将栈顶两long型数值相除并将结果压入栈顶
0x6efdiv将栈顶两float型数值相除并将结果压入栈顶
0x6fddiv将栈顶两double型数值相除并将结果压入栈顶
0x70irem将栈顶两int型数值作取模运算并将结果压入栈顶
0x71lrem将栈顶两long型数值作取模运算并将结果压入栈顶
0x72frem将栈顶两float型数值作取模运算并将结果压入栈顶
0x73drem将栈顶两double型数值作取模运算并将结果压入栈顶
0x74ineg将栈顶int型数值取负并将结果压入栈顶
0x75lneg将栈顶long型数值取负并将结果压入栈顶
0x76fneg将栈顶float型数值取负并将结果压入栈顶
0x77dneg将栈顶double型数值取负并将结果压入栈顶
0x78ishl将int型数值左移指定位数并将结果压入栈顶
0x79lshl将long型数值左移指定位数并将结果压入栈顶
0x7aishr将int型数值右(带符号)移指定位数并将结果压入栈顶
0x7blshr将long型数值右(带符号)移指定位数并将结果压入栈顶
0x7ciushr将int型数值右(无符号)移指定位数并将结果压入栈顶
0x7dlushr将long型数值右(无符号)移指定位数并将结果压入栈顶
0x7eiand将栈顶两int型数值"按位与"并将结果压入栈顶
0x7fland将栈顶两long型数值"按位与"并将结果压入栈顶
0x80ior将栈顶两int型数值"按位或"并将结果压入栈顶
0x81lor将栈顶两long型数值"按位或"并将结果压入栈顶
0x82ixor将栈顶两int型数值"按位异或"并将结果压入栈顶
0x83lxor将栈顶两long型数值"按位异或"并将结果压入栈顶
0x84iinc将指定int型变量增加指定值(如i++, i–, i+=2等)
0x85i2l将栈顶int型数值强制转换为long型数值并将结果压入栈顶
0x86i2f将栈顶int型数值强制转换为float型数值并将结果压入栈顶
0x87i2d将栈顶int型数值强制转换为double型数值并将结果压入栈顶
0x88l2i将栈顶long型数值强制转换为int型数值并将结果压入栈顶
0x89l2f将栈顶long型数值强制转换为float型数值并将结果压入栈顶
0x8al2d将栈顶long型数值强制转换为double型数值并将结果压入栈顶
0x8bf2i将栈顶float型数值强制转换为int型数值并将结果压入栈顶
0x8cf2l将栈顶float型数值强制转换为long型数值并将结果压入栈顶
0x8df2d将栈顶float型数值强制转换为double型数值并将结果压入栈顶
0x8ed2i将栈顶double型数值强制转换为int型数值并将结果压入栈顶
0x8fd2l将栈顶double型数值强制转换为long型数值并将结果压入栈顶
0x90d2f将栈顶double型数值强制转换为float型数值并将结果压入栈顶
0x91i2b将栈顶int型数值强制转换为byte型数值并将结果压入栈顶
0x92i2c将栈顶int型数值强制转换为char型数值并将结果压入栈顶
0x93i2s将栈顶int型数值强制转换为short型数值并将结果压入栈顶
0x94lcmp比较栈顶两long型数值大小, 并将结果(1, 0或-1)压入栈顶
0x95fcmpl比较栈顶两float型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将-1压入栈顶
0x96fcmpg比较栈顶两float型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将1压入栈顶
0x97dcmpl比较栈顶两double型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将-1压入栈顶
0x98dcmpg比较栈顶两double型数值大小, 并将结果(1, 0或-1)压入栈顶; 当其中一个数值为NaN时, 将1压入栈顶
0x99ifeq当栈顶int型数值等于0时跳转
0x9aifne当栈顶int型数值不等于0时跳转
0x9biflt当栈顶int型数值小于0时跳转
0x9cifge当栈顶int型数值大于等于0时跳转
0x9difgt当栈顶int型数值大于0时跳转
0x9eifle当栈顶int型数值小于等于0时跳转
0x9fif_icmpeq比较栈顶两int型数值大小, 当结果等于0时跳转
0xa0if_icmpne比较栈顶两int型数值大小, 当结果不等于0时跳转
0xa1if_icmplt比较栈顶两int型数值大小, 当结果小于0时跳转
0xa2if_icmpge比较栈顶两int型数值大小, 当结果大于等于0时跳转
0xa3if_icmpgt比较栈顶两int型数值大小, 当结果大于0时跳转
0xa4if_icmple比较栈顶两int型数值大小, 当结果小于等于0时跳转
0xa5if_acmpeq比较栈顶两引用型数值, 当结果相等时跳转
0xa6if_acmpne比较栈顶两引用型数值, 当结果不相等时跳转
0xa7goto无条件跳转
0xa8jsr跳转至指定的16位offset位置, 并将jsr的下一条指令地址压入栈顶
0xa9ret返回至本地变量指定的index的指令位置(一般与jsr或jsr_w联合使用)
0xaatableswitch用于switch条件跳转, case值连续(可变长度指令)
0xablookupswitch用于switch条件跳转, case值不连续(可变长度指令)
0xacireturn从当前方法返回int
0xadlreturn从当前方法返回long
0xaefreturn从当前方法返回float
0xafdreturn从当前方法返回double
0xb0areturn从当前方法返回对象引用
0xb1return从当前方法返回void
0xb2getstatic获取指定类的静态域, 并将其压入栈顶
0xb3putstatic为指定类的静态域赋值
0xb4getfield获取指定类的实例域, 并将其压入栈顶
0xb5putfield为指定类的实例域赋值
0xb6invokevirtual调用实例方法
0xb7invokespecial调用超类构建方法, 实例初始化方法, 私有方法
0xb8invokestatic调用静态方法
0xb9invokeinterface调用接口方法
0xbainvokedynamic调用动态方法
0xbbnew创建一个对象, 并将其引用引用值压入栈顶
0xbcnewarray创建一个指定的原始类型(如int, float, char等)的数组, 并将其引用值压入栈顶
0xbdanewarray创建一个引用型(如类, 接口, 数组)的数组, 并将其引用值压入栈顶
0xbearraylength获取数组的长度值并压入栈顶
0xbfathrow将栈顶的异常抛出
0xc0checkcast检验类型转换, 检验未通过将抛出 ClassCastException
0xc1instanceof检验对象是否是指定类的实际, 如果是将1压入栈顶, 否则将0压入栈顶
0xc2monitorenter获得对象的锁, 用于同步方法或同步块
0xc3monitorexit释放对象的锁, 用于同步方法或同步块
0xc4wide扩展本地变量的宽度
0xc5multianewarray创建指定类型和指定维度的多维数组(执行该指令时, 操作栈中必须包含各维度的长度值), 并将其引用压入栈顶
0xc6ifnull为null时跳转
0xc7ifnonnull不为null时跳转
0xc8goto_w无条件跳转(宽索引)
0xc9jsr_w跳转至指定的32位offset位置, 并将jsr_w的下一条指令地址压入栈顶
禁止指令重排

计算机在执行程序时，为了提高性能，编译器和处理器常常会对指令重排，一般分为以下三种：

源代码 -> 编译器优化的重排 -> 指令并行的重排 -> 内存系统的重排 -> 最终执行指令

单线程环境里面确保最终执行结果和代码顺序的结果一致

处理器在进行重排序时，必须要考虑指令之间的数据依赖性

多线程环境中线程交替执行，由于编译器优化重排的存在，两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

单线程不会指令重排，多线程会。

代码测试1
public void mySort() {
	int x = 11;
	int y = 12;
	x = x + 5;
	y = x * x;
}

按照正常单线程环境，执行顺序是 1 2 3 4

但是在多线程环境下，可能出现以下的顺序：

  • 2 1 3 4
  • 1 3 2 4

上述的过程就可以当做是指令的重排，即内部执行顺序，和我们的代码顺序不一样

但是指令重排也是有限制的，即不会出现下面的顺序

  • 4 3 2 1

因为处理器在进行重排时候，必须考虑到指令之间的数据依赖性

因为步骤 4：需要依赖于y的申明，以及x的申明，故因为存在数据依赖，无法首先执行

案例1

int a,b,x,y = 0

线程1线程2
x = a;y = b;
b = 1;a = 2;
x = 0; y = 0

因为上面的代码，不存在数据的依赖性，因此编译器可能对数据进行重排

线程1线程2
b = 1;a = 2;
x = a;y = b;
x = 2; y = 1

这样造成的结果，和最开始的就不一致了，这就是导致重排后，结果和最开始的不一样，因此为了防止这种结果出现，volatile就规定禁止指令重排，为了保证数据的一致性

代码测试2
/**
 * ResortSeqDemo
 *
 * @author: wzq
 * @create: 2020-03-10-16:08
 */
public class ResortSeqDemo {
    /*volatile*/int a= 0;
    /*volatile*/boolean flag = false;

    public void method01() {
        a = 1;
        flag = true;
    }

    public void method02() {
        if(flag) {
            a = a + 5;
            System.out.println("reValue:" + a);
        }
    }
}

我们按照正常的顺序，分别调用method01() 和 method02() 那么，最终输出就是 a = 6

但是如果在多线程环境下，因为方法1 和 方法2，他们之间不能存在数据依赖的问题，因此原先的顺序可能是

a = 1;
flag = true;

a = a + 5;
System.out.println("reValue:" + a);

但是在经过编译器，指令，或者内存的重排后，可能会出现这样的情况

flag = true;

a = a + 5;
System.out.println("reValue:" + a);

a = 1;

也就是先执行 flag = true后，另外一个线程马上调用方法2，满足 flag的判断，最终让a + 5，结果为5，这样同样出现了数据不一致的问题

为什么会出现这个结果：多线程环境中线程交替执行，由于编译器优化重排的存在（为了提高性能），两个线程中使用的变量能否保证一致性是无法确定的，结果无法预测。

这样就需要通过volatile来修饰，来保证线程安全性。

原理

Volatile实现禁止指令重排优化，从而避免了多线程环境下程序出现乱序执行的现象

首先了解一个概念，内存屏障（Memory Barrier）又称内存栅栏，是一个CPU指令，它的作用有两个：

  • 保证特定操作的顺序
  • 保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）

由于编译器和处理器都能执行指令重排的优化，如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说 通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。 内存屏障另外一个作用是刷新出各种CPU的缓存数，因此任何CPU上的线程都能读取到这些数据的最新版本。

在这里插入图片描述

也就是过在Volatile的写 和 读的时候，加入屏障，防止出现指令重排的

线程安全获得保证：

工作内存与主内存同步延迟现象导致的可见性问题

  • 可通过synchronized或volatile关键字解决，他们都可以使一个线程修改后的变量立即对其它线程可见

对于指令重排导致的可见性问题和有序性问题

  • 可以使用volatile关键字解决，因为volatile关键字的另一个作用就是禁止重排序优化
应用
单例模式DCL代码

首先回顾一下，单线程下的单例模式代码，只需实例化一次

/**
 * SingletonDemo（单例模式）
 *
 * @author: wzq
 * @create: 2020-03-10-16:40
 */
public class SingletonDemo {

    private static SingletonDemo instance = null;

    private SingletonDemo () {
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo");
    }

    public static SingletonDemo getInstance() {
        if(instance == null) {
            instance = new SingletonDemo();
        }
        return instance;
    }

    public static void main(String[] args) {
        // 这里的 == 是比较内存地址
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
    }
}

最后输出的结果

在这里插入图片描述

但是在多线程的环境下，我们的单例模式是否还是同一个对象了

/**
 * SingletonDemo（单例模式）
 *
 * @author: wzq
 * @create: 2020-03-10-16:40
 */
public class SingletonDemo {

    private static SingletonDemo instance = null;

    private SingletonDemo () {
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo");
    }

    public static SingletonDemo getInstance() {
        if(instance == null) {
            instance = new SingletonDemo();
        }
        return instance;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}

从下面的结果我们可以看出，我们通过SingletonDemo.getInstance() 获取到的对象，并不是同一个，而是被下面几个线程都进行了创建，那么在多线程环境下，单例模式如何保证呢？

在这里插入图片描述

解决方法1

引入synchronized关键字

    public synchronized static SingletonDemo getInstance() {
        if(instance == null) {
            instance = new SingletonDemo();
        }
        return instance;
    }

输出结果

在这里插入图片描述

我们能够发现，通过引入Synchronized关键字，能够解决高并发环境下的单例模式问题

但是synchronized属于重量级的同步机制，它只允许一个线程同时访问获取实例的方法，但是为了保证数据一致性，而减低了并发性，因此采用的比较少

解决方法2

通过引入DCL Double Check Lock 双端检锁机制

就是在进来和出去的时候，进行检测

    public static SingletonDemo getInstance() {
        // 双端检锁机制
        if(instance == null) {
            // 同步代码段的时候，进行检测
            synchronized (SingletonDemo.class) {
                if(instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

最后输出的结果为：

在这里插入图片描述

从输出结果来看，确实能够保证单例模式的正确性，但是上面的方法还是存在问题的

DCL（双端检锁）机制不一定是线程安全的，原因是有指令重排的存在，加入volatile可以禁止指令重排

原因是在某一个线程执行到第一次检测的时候，读取到 instance 不为null，instance的引用对象可能没有完成实例化。因为 instance = new SingletonDemo()；可以分为以下三步进行完成：

  • memory = allocate(); // 1、分配对象内存空间
  • instance(memory); // 2、初始化对象
  • instance = memory; // 3、设置instance指向刚刚分配的内存地址，此时instance != null

但是我们通过上面的三个步骤，能够发现，步骤2 和 步骤3之间不存在 数据依赖关系，而且无论重排前 还是重排后，程序的执行结果在单线程中并没有改变，因此这种重排优化是允许的。

  • memory = allocate(); // 1、分配对象内存空间
  • instance = memory; // 3、设置instance指向刚刚分配的内存地址，此时instance != null，但是对象还没有初始化完成
  • instance(memory); // 2、初始化对象

这样就会造成什么问题呢？

也就是当我们执行到重排后的步骤2，试图获取instance的时候，会得到null，因为对象的初始化还没有完成，而是在重排后的步骤3才完成，因此执行单例模式的代码时候，就会重新在创建一个instance实例

指令重排只会保证串行语义的执行一致性（单线程），但并不会关系多线程间的语义一致性

所以当一条线程访问instance不为null时，由于instance实例未必已初始化完成，这就造成了线程安全的问题

所以需要引入volatile，来保证出现指令重排的问题，从而保证单例模式的线程安全性

private static volatile SingletonDemo instance = null;
最终代码
/**
 * SingletonDemo（单例模式）
 *
 * @author: 陌溪
 * @create: 2020-03-10-16:40
 */
public class SingletonDemo {

    private static volatile SingletonDemo instance = null;

    private SingletonDemo () {
        System.out.println(Thread.currentThread().getName() + "\t 我是构造方法SingletonDemo");
    }

    public static SingletonDemo getInstance() {
        if(instance == null) {
            // 同步代码段的时候，进行检测
            synchronized (SingletonDemo.class) {
                if(instance == null) {
                    instance = new SingletonDemo();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
//        // 这里的 == 是比较内存地址
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());
//        System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance());

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                SingletonDemo.getInstance();
            }, String.valueOf(i)).start();
        }
    }
}
wzq_55552
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JUC底层讲解，面试可用。
10-09
juc面试总结，很详细，，校招冲刺可以看一下
最详细JUC面试内容解析.docx
06-09
Juc（JAVA.util.concurrent[并发]）v2.0复习版 文档\Java JUC.pdf 内存可见性  内存可见性（Memory Visibility）是指当某个线程正在使用对象状态 而另一个线程在同时修改该状态，需要确保当一个线程修改了对象 ...
多线程(三) -- 内存(二) -- Volatile详解
weixin_39724194的博客
07-16 1361
Volatile的作用： 先说结论： 保证变量对所有线程的可见性，但不能保证原子性。 禁止指令重排序优化。 volatile不会导致阻塞 内存与缓存与并发： 要了解volatile，就要先对CPU,CPU cache和主存有所有了解。 主存就是我们平时说的内存，它的读写速度很慢，而CPU运算速度很快，为了弥补二者的差异，在CPU和主存之间引入了CPU Cache, 现在很多CPU都会有三层Cache,分别称为L1,L2和L3，其中L1最靠近CPU，缓存速度也最快，L1这块缓存被分为了两个部分，一部分是指
JUC-内存
诗和远方，代码和你
07-21 206
该缓存行只被缓存在该CPU的缓存中，并且是被修改过的，与主存中的数据不一致(dirty)，该缓存行中的内存需要在未来的某个时间点（其它CPU读取主存中相应数据之前）写回(writeback)主存。CPU处理器速度远远大于在主内存中的，为了解决速度差异，在它们之间架设了多级缓存，如L1、L2、L3级别的缓存，这些缓存离CPU越近就越快，将频繁操作的数据缓存到这里，加快访问速度。，线程对所有变量的操作都是先对变量进行拷贝，然后在工作内存中进行，不能直接操作主内存中的变量；...
JUC面试（一）——JUC&JMM&volatile 1.0
qq_43409401的博客
01-16 547
Volatile是Java虚拟机提供的轻量级的同步机制（三大特性）：保证可见性、不保证原子性、禁止指令重排。
JUC（5）JMM&&Volatile关键字
weixin_45789266的博客
01-28 87
1. JMM 8种操作执行顺序 lock read load use assign store write unlock lock(锁定)，作用于主内存中的变量，把变量标识为线程独占的状态。 read(读取)，作用于主内存的变量，把变量的值从主内存传输到线程的工作内存中，以便下一步的load操作使用。 load(加载)，作用于工作内存的变量，把read操作主存的变量放入到工作内存的变量副本中。 use(使用)，作用于工作内存的变量，把工作内存中的变量传输到执行引擎，每当虚拟机遇到一个需要使用到变量
JUC并发编程——深入了解volatile关键字
weixin_39555954的博客
12-29 400
一、volatile
JUC并发编程 04——Java内存模型之JMM
最新发布
qq_62767608的博客
12-13 1033
JUC并发编程 04——Java内存模型之JMM
JUC —— Volatile
weixin_46540606的博客
02-09 964
Volatile Volatile是java虚拟机提供的轻量级的同步机制 保证可见性 不保证原子性 禁止指令重排序 什么是JMM JMM：java内存模型，不存在的东西，是一个概念、一个约定 关于JMM的一些同步的约定： 线程解锁前，必须把共享变量立刻刷会主存 线程加锁前，必须读取主存中的最新值到工作内存中 加锁和解锁是同一把锁 线程 工作内存 主内存 JMM八种操作 关于主内存与工作内存之间的交互协议，即一个变量如何从主内存拷贝到工作内存。如何从工作内存同步到主内存中的实现细节。java内存模型
JUC并发编程—— volatile 关键字详解
万里顾一程的博客
09-26 192
文章目录JUC并发编程—— volatile 关键字详解1、volatile 简介2、可见性和非原子性验证3、volatile与synchronized比较 JUC并发编程—— volatile 关键字详解 1、volatile 简介 并发编程三个特性： 1、原子性：一段操作一旦开始就会一直运行到底，中间不会被其它线程打断，这段操作可以是一个操作，也可以是多个操作。 2、可见性：当一个线程修改了共享变量的值，其它线程能立即感知到这种变化。 3、有序性：在本线程内观察，操作都是有序的；如果在一个线程中观察另外
Java——聊聊JUC中的volatile与内存屏障
胜天半子祁同伟
09-27 4719
Java——聊聊JUC中的volatile与内存屏障
这就是标题—— JUC.pdf
05-19
JUC是什么 线程 进程 / 线程 线程状态 wait / sleep 并发 / 并行 Lock 使用Lock锁 可重入锁 公平锁 / 非公平锁 Synchronized / Lock 线程通讯 wait()、notify()和notifyAll() 虚假唤醒 Condition 定制化通信 多线程...
Java——JUC
12-29
用于定义类似于线程的自定义子系统,包括线程池,异步 IO 和轻量级任务框架;包含下载地址
JUC基石——Unsafe类
12-21
我们经常在JUC包下的ConcurrentHashMap、Atomic开头的原子操作类、AQS以及LockSupport里面看到Unsafe类的身影，这个Unsafe类究竟是干什么的，本文可以带着读者一探究竟。 Java和C++、C语言的一个重要区别，就是Java...
BindException、ConstraintViolationException、MethodArgumentNotValidException入参验证异常分析和全局异常处理解决方法
热门推荐
qq_43409401的博客
04-22 1万+
Spring validation验证框架注解 Spring validation验证框架提供了大量接口入参检验注解，注意三个非空注解： @NotNull：验证对象是否不为null, 无法查检长度为0的字符串 @NotBlank：检查约束 (字符串) 是不是Null还有被Trim的长度是否大于0，只对字符串,且会去掉前后空格 @NotEmpty：检查(集合)约束元素是否为NULL或者是EMPTY @Size(min=,max=)：验证对象（Array,Collection,Map,String）长度是否在
hutool工具ExcelWriter设置单个单元格样式
qq_43409401的博客
01-17 9004
官网自定义样式： ExcelWriter writer = ...; // 定义单元格背景色 StyleSet style = writer.getStyleSet(); // 第二个参数表示是否也设置头部单元格背景 style.setBackgroundColor(IndexedColors.RED, false); //设置内容字体 Font font = writer.createFont(); font.setBold(true); font.setColor(Font.COLOR_RED)
Mybatis——数据库json字段映射实体类
qq_43409401的博客
07-07 6860
Mybatis——数据库json字段映射实体类
文件流转MultipartFile
qq_43409401的博客
06-29 6549
Java后端，文件流转MultipartFile
java juc面试
10-06
Java JUC（Java Util Concurrent）是Java并发编程中的一个重要模块，提供了一系列的工具类和API，用于实现高效的并发编程。 Java JUC包括了以下几个核心组件： 1. 锁：Java提供了多种锁机制来实现并发编程，例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

wzq_55552

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值