一.底层原理

image.png

二.从Java代码到CPU指令的变化过程?

我们在Java代码中，使用的控制并发的手段例如synchronized关键字，最终也是要转化为CPU指令来生效的，我们来回顾一-下从Java代码到最终执行的CPU指令的流程:
1.最开始，我们编写的Java代码,是java文件
2.在编译(javac命令) 后，从刚才的 java文件会变出一个新的Java字节码文件(.class)
3.JVM会执行刚才生成的字节码文件( .class),并把字节码文件转化为机器指令
4.机器指令可以直接在CPU上执运行，也就是最终的程序执行
而不同的JVM实现会带来不同的“翻译”，不同的CPU平台的机器指令又干差万别;所以我们在java代码层写的各种Lock,其实最后依赖的是JVM的具体实现(不同版本会有不同实现)和CPU的指令,才能帮我们达到线程安全的效果。由于最终效果依赖处理器，不同处理器结果不一样，这样无法保证并发安全，所以需要一个标准，让多线程运行的结果可预期，这个标准就是JMM。

三.JVM内存结构VSJava内存模型VSJava对象模型

1.内存模型

image.png

2.内存结构

堆（heap）：存放实例对象，运行时动态分配,不需要事先告诉编译器

image.png

3.对象模型

image.png

四.JMM是规范（重排序.可见性.原子性）

是一组规范，需要各个JVM的实现来遵守JMM规范,以便于开发者可以利用这些规范，更方便地开发多线程程序，如果没有这样的一个JMM内存模型来规范，那么很有可能经过了不同JVM的不同规则的重排序之后,导致不同虚拟机上运行的结果不一样。
◆volatile、 synchronized、 Lock等的原理都是JMM
◆如果没有JMM ,那就需要我们自己指定什么时候用内存栅栏等,那是相当麻烦的,幸好有了JMM ,让我们只需要用同步工具和关键字就可以开发并发程序。

1.重排序

◆什么是重排序:在线程1内部的两行代码的实际执行顺序和代码在Java文件中的顺序不一致,代码指令并不是严格按照代码语句顺序执行的,它们的顺序被改变了,这就是重排序,这里被颠倒的是y=a和b=1这两行语句。

下面代码由于两个线程执行顺序的不同（虽然已经加入 CountDownLatch latch = new CountDownLatch(1),但两个线程大概率时间不会同时进行），因此会出现下面三种常见情况

• a=1;x=b(0);b=1;y=a(1),最终结果x=0.y=1
• b=1;y=a(0);b=1;x=b(1),最终结果x=1.y=0
• b=1;a=1(0);x=b;y=a(1),最终结果x=1.y=1

但是我们会认为一个线程内部执行顺序是自上而下的，不会发生x = 0,y =0的情况，但代码显示2940次的时候发生了重排序，执行顺序可能为：y=a;a=1;x=b;b=1;(代码中两个线程先对a和b赋值，再对x和y赋值)

image.png

package jmm;

import java.util.concurrent.CountDownLatch;

/*
演示重排序 “直到达到某个条件才停止”,测试小概率事件
 */
public class OutOfOrderExecution {
    private static int x = 0, y = 0;
    private static int a = 0, b = 0;

    public static void main(String[] args) throws InterruptedException {
        int i = 0;
        for (; ; ) {
            i++;
            x = 0;
            y = 0;
            a = 0;
            b = 0;

            CountDownLatch latch = new CountDownLatch(1);
            Thread one = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    a = 1;
                    x = b;
                }
            });
            Thread two = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        latch.await();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    b = 1;
                    y = a;
                }
            });
            one.start();
            two.start();
            latch.countDown();
            one.join();
            two.join();
            String  result = "第"+i+"次"+"X=" + x + "y=" + y;
            if(x == 0 && y ==0){ //自己定义出现不同结果
                System.out.println(result);
                break;
            }else {
                System.out.println(result);
            }



        }
    }

}

◆重排序的好处：提高处理速度

image.png

◆重排序的3中情况

1.编译器优化
编译器(包括JVM, JIT编译器等)出于优化的目的(例如当前有了数据a,那么如果把对a的操作放到一起效率会更高，避免 了读取b后又返回来重新读取a的时开销)，在编译的过程中会进行一定程度的重排，导致生成的机器指令和之前的字节码的顺序不一致。在刚才的例子中，编译器将y=a和b=1这两行语句换了顺序(也可能是线程2的两行换了顺序,同理)，因为它们之间没有数据依赖关系，那就不难得到x=0, y=0这种结果了。
2.指令重排序
CPU的优化行为，和编译器优化很类似，是通过乱序执行的技术，来提高执行效率。所以就算编译器不发生重排，CPU 也可能对指令进行重排，所以我们开发中一-定要考虑到重排序带来的后果。
3.内存的“重排序”
内存系统内不存在重排序，但是内存会带来看上去和重排序一样的效果， 所以这里的“重排序”打了双引号。由于内存有缓存的存在，在JMM里表现为主存和本地内存，由于主存和本地内存的不一致,会使得程序表现出乱序的行为。在刚才的例子中，假设没编译器重排和指令重排，但是如果发生了内存缓存不一致，也可能导致同样的情况:线程1修改了a的值，但是修改后并没有写回主存，所以线程2是看不到刚才线程1对a的修改的，所以线程2看到a还是等于0。同理,线程2对b的赋值操作也可能由于没及时写回主存，导致线程1看不到刚才线程2的修改。

2.可见性

• 代码演示

package jmm;

public class FileldVisibility {
    int a = 1;
    int b = 2;

    private void change() {
        a = 3;
        b = a;
    }
    private void print () {
        System.out.println("b=" + b + ";a=" + a);
    }

    public static void main(String[] args) {
        while (true) {
            FileldVisibility test = new FileldVisibility();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    test.change();
                }
            }).start();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    test.print();
                }
            }).start();
        }



    }
}

• 可能出现的四种情况

常见情况：a = 3 ,b = 2; a = 1, b = 2; a = 3, b = 3
特殊情况 b=3 a=1:两个线程间的通信需要读取主存信息但因为时间延迟代价,一个线程一对a,b的值进行了修改,但另一个线程只看到了一部分。

image.png

• 解决办法：用volatile关键字修饰变量

• 什么是主内存和本地内存
  

  Java作为高级语言，屏蔽了CPU多层缓存这些底层细节，用JMM定义了一套读写内存数据的规范，虽然我们不再需要关心一级缓存和二级缓存的问题，但是，JMM抽象了主内存和本地内存的概念。这里说的本地内存并不是真的是一块给每 个线程分配的内存，而是JMM的一个抽象，是对于寄存器、-级缓存、二级缓存等的抽象。主纳存和本地内存的图示:
  image.png

• JMM有以下规定:
  1.所有的变量都存储在主内存中，同时每个线程也有自己独立的工作内存,工作内存中的变量内容是主内存中的拷贝
  2.线程不能直接读写主内存中的变量，而是只能操作自己工作内存中的变量,然后再同步到主内存中
  3.主内存是多个线程共享的，但线程间不共享工作内存，如果线程间需要通信，必须借助主内存中转来完成所有的共享变量存在于主納存中，每个线程有自己的本地内存，且线程读写共享数据也是通过本地内存交换的,所以才导致了可见性问题。

3.原子性

• 定义： 一系列操作，要么全部执行成功，要么全部不执行，不可分割，不会出现执行一半的情况
• 原子操作包含内容：（除long和double之外的基本类型( int, byte, boolean, short, char,float )的赋值操作）
  问题描述:官方文档、对于64位的值的写入,可以分为两个32位的操作进行写入、读取错误、使用volatile解决
  结论:在32位上的JVM_上, long和double的操作不是原子的, 但是在64位的JVM_上是原子的实际开发中:商用Java虚拟机中不会出现