JMM模型与volatile详解（一）

JMM模型

Java内存模型（Java Memory Model）是一种抽象的概念；并不真实存在，是一种规则或规范，通过这组规范定义了程序中各个变量（包括实例字段，静态字段和构造数组对象的元素）的访问方式。JVM运行程序的实体是线程，而每个线程创建时，JVM都会为其创建一个工作内存，用于存储线程私有的数据。
而Java内存模型中规定所有的变量都存储在主内存中，主内存是共享内存区域，所有线程都可以访问，但线程对变量的操作必须在工作内存中进行，首先将变量从主内存中拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后再将变量写回主内存，不能直接操作主内存中的变量，工作内存中存出着主内存中的变量副本拷贝。
前面说过，工作内存是每个线程的私有数据区域，因此不同的线程间无法访问对方的工作内存，线程间的通信必须通过主内来完成。

JMM不同于JVM内存区域模型

• JMM为java内存模型，不是java内存布局，不是所谓的堆栈等。
• 每个java线程都在自己的工作内存来操作数据，首先从主内存中读取获得一根拷贝，操作完后再写回主内
• JMM与JVM内存区域的划分是不同的概念层次。
• JMM描述的是一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式。
• JMM是围绕原子性，有序性，可见性展开。
• JMM是针对的是多线程；
• JVM针对的GC；

相似点是都存在共享数据区域和私有数据区域。

• JMM的工作内存类似JVM的结构可以是Java栈。
• JMM的主内存类似JVM结构的堆，方法区。

JMM模型图

主内存

• 主要存储的是Java实例对象，所有线程创建的实例对象都存放在主内存中，不管该实例对象是成员变量还是方法中的本地变量。
• 当然也包括了共享的类信息、常 量、静态变量。
• 由于是共享数据区域，多条线程对同一个变量进行访问可能会发生线程安全问题

工作内存

• 存储着主内存中的变量副本拷贝。
• 每个线程只能访问自己的工作内存，工作内存是每个线程的私有数据，线程间无法相互访问对方的工作内存，因此存储在工作内存的数据不存在线程安全问题。
• 线程拥有的自己栈，方法中包含了基本数据类型变量，这些变量存储在线程的栈帧结构中。如果是引用类型，变量的引用存储在栈帧中，实例存放在主内存中。
• static变 量以及类本身相关信息将会存储在主内存中。
  模型图如下所示：
  

Java内存模型与硬件内存架构的关系

• Java多线程的执行最终会映射到硬件处理器上执行；
• Java内存模型和硬件内存并不一致。硬件内存只有寄存器，缓存内存Cache，主内存的概念；
• Java内存模型是主内存和工作内存；
• 工作内存和主内存都可能存储计算机主内存中，也可以存储在CPU缓存或者寄存器中。
• 两者是交叉关系。
  

JMM存在的必要性

每个线程创建时，JVM都会为其创建一个工作内存，用于存放线程私有的数据，线程与主内存中的变量操作必须通过工作内存间接完成，主要过程是将变量 从主内存拷贝的每个线程各自的工作内存空间，然后对变量进行操作，操作完成后再将变量 写回主内存，如果存在两个线程同时对一个主内存中的实例对象的变量进行操作就有可能诱 发线程安全问题

如上图所示，两个线程对同一个变量进行读写操作，线程2的读取到值不确定，如果在线程1更新前读取，值就为10，如果在线程1更新后读取，值就为20；
于主内存与工作内存之间的具体交互细节主要涉及八种操作。

数据同步八大原子操作

• lock（锁定）：作用域主内存的变量，将变量改为独占状态；
• unlock （解锁）: 作用主内存的变量，将锁定状态（独占状态）的对象解锁（解放）出来，其他线程就可以占有（锁）该变量；
• read （读取）：作用域主内存的变量，将主内存中的变量传输到工作内存中
• load (加载) :作用于工作内存的变量，将read传输到工作内存中的变量放入工作内存的变量副本中；
• use (使用):作用于工作内存的变量，把工作内存变量副本中的变量值传递给执行引擎；
• assign（赋值）：作用于工作内存的变量，将计算后的结果赋值给工作内存中的变量副本；
• store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到工作内存 中，以便随后的write的操作。
• write(写）： 将工作内存中的变量协会主内存的变量中。

如果要把一个变量从主内存中复制到工作内存中，就需要按顺序地执行read和load操 作，如果把变量从工作内存中同步到主内存中，就需要按顺序地执行store和write操作。

同步规则分析

1）不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内 存中
2）use之前必须load，store之前必须assign；
3）可以lock多次，但是必须unlock同样次数；
4）如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个 变量之前需要重新执行load或assign操作初始化变量的值。
5）对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write 操作

注意：4,5可以体现JMM的可见性；

JMM的可见性、原子性，有序性

原子性

• 指一个操作是不可中断的，只能一次性执行完。
• 在多线程环境下，一个操作一旦开始就不 会被其他线程影响

 X = x+1;
 //这行代码不是原子的，JVM会先读取x的值，再进行+1操作，再赋值给X；
 //多个线程同时执行这行代码，可能出现不同的结果；

可见性

当一个线程修改某个共享变量的值，其他线程是否能够立马知道该值发生了修改。

• 对于串行程序来说，可见性是不存在的， 因为我们在任何一个操作中修改了某个变量的值，后续的操作中都能读取这个变量值，并且 是修改过的新值。
• 多线程就不一样了，一个线程在工作内存操作完共享变量后写会主内存中，如果其他线程也持有该变量的副本，需要通知这些线程，该变量值已经发生改变。否则这些线程基于原来的变量副本操作，实际上操作的是脏数据。
• 工作内存与主内存同步延迟现象造成了可见性问题；

有序性

有序性指的是程序是顺序依次执行的。

• 单线程是依次执行的。
• 多线程就不一定了；可能出现乱序现象，因为程序编译成机器码指令会出现指令重排现象，重排后的指令顺序和原来的不一样，但是最终的执行结果是一致的。
• 多行代码，变量之间不存在依赖关系，就可能存在指令重拍问题；

int x=1;
int y=2;
//两行代码不存在依赖关系，是可以先执行y=2,再x=1的。

JMM如何解决原子性&可见性&有序性问题

原子性问题

JVM自身提供的对基本数据类型读写操作的原子性外，使用synchronized和可重入锁ReentrantLock实现原子性；两者可以保证同一时刻只有一个线程访问某代码块；

可见性问题

volatile关键字可以保证可见性。当一个共享变量被volatile修饰时，他会保证修改的值立刻被其他的线程看到，即修改的值更新到主内存后，当其他线程需要读取时，会去内存中读取新值。
synchronized与ReentrantLock也可以保证可见性，因为它们可以保证任一时刻只有一个 线程能访问共享资源，并在其释放锁之前将修改的变量刷新到内存中

有序性问题

volatile关键字可以保证一定的有序性，禁止指令重排；另外可以使用synchronized和lock来保证有序性，synchronized和lock保证每一时刻只有一个线程执行同步带吗，相当于让线程顺序执行同步带吗，自然就保证了有序性，但不能禁止指令重排

• Java内存模型具备一些先天的“有序性”。
  即不需要通过任何手段 就能够得到保证的有序性，这个通常也称为happens-before 原则。如果两个操作的执行次 序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以 随意地对它们进行重排序。
• 指令重排序：java语言规范规定JVM线程内部维持顺序化语义。
  只要程序的最终结果与他顺序化情况的结果相等，那么指令的执行顺序可以和代码顺序不一致，这个过程为指令重排；
  JVM能根据处理器特性（CPU多级缓存系统、多核处 理器等）适当的对机器指令进行重排序，使机器指令能更符合CPU的执行特性，最大限度的发挥机器性能。

下图为从源码到最终执行的指令序列示意图：

as-if-serial

• 不管怎么重排序，单线程的执行结果不能被改变。
• 编译器和处理器不会对存在数据依赖关系的操作进行重排序，因为这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作就可 能被编译器和处理器重排序

happens-before 原则

• 只靠sychronized和volatile关键字来保证原子性、可见性以及有序性，那么编写并发 程序可能会显得十分麻烦。
• ，Java使用新的JSR-133内存模型，提 供了happens-before 原则来辅助保证程序执行的原子性、可见性以及有序性的问题，它是 判断数据是否存在竞争、线程是否安全的依据，
  1. 程序顺序原则，即在一个线程内必须保证语义串行性，也就是说按照代码顺序执行
  2. volatile规则 volatile变量的写，先发生于读，这保证了volatile变量的可见性，简 单的理解就是，volatile变量在每次被线程访问时，都强迫从主内存中读该变量的 值，而当该变量发生变化时，又会强迫将最新的值刷新到主内存，任何时刻，不同的 线程总是能够看到该变量的最新值。
  3. 线程启动规则 线程的start()方法先于它的每一个动作，即如果线程A在执行线程B 的start方法之前修改了共享变量的值，那么当线程B执行start方法时，线程A对共享 变量的修改对线程B可见
  4. 传递性 A先于B ，B先于C 那么A必然先于C
  5. 锁规则 解锁(unlock)操作必然发生在后续的同一个锁的加锁(lock)之前，也就是 说，如果对于一个锁解锁后，再加锁，那么加锁的动作必须在解锁动作之后(同一个 锁)。

volatile关键字

volatile是Java虚拟机提供的轻量级的同步机制。

• 不能保证原子性
• 保证volatile修饰的共享变量对所有线程是可见的。也就是当一个线程修改 了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。
• 禁止指令重排序

volatile的可见性

关于volatile的可见性作用，我们必须意识到被volatile修饰的变量对所有线程总数立即 可见的，对volatile变量的所有写操作总是能立刻反应到其他线程中。

示例

class MyData{
    int number=0;
    //volatile int number=0;

    AtomicInteger atomicInteger=new AtomicInteger();
    public void setTo60(){
        this.number=60;
    }

    //此时number前面已经加了volatile，但是不保证原子性
    public void addPlusPlus(){
        number++;
    }

    public void addAtomic(){
        atomicInteger.getAndIncrement();
    }
}
public class VolatileTest {
	public static void main(String[] args) {
		System.out.println("原子性测试");
	    MyData myData=new MyData();
	    for(int i=1;i<=20;i++) {
	    	new Thread(()->{
	    		for(int j=0;j<1000;j++) {
	    			myData.addPlusPlus();
	    			myData.addAtomic();
	    		}
	    	},String.valueOf(i)).start();
	    }
	    while (Thread.activeCount()>2){
            Thread.yield();
        }
	    System.out.println(myData.number);
	    System.out.println(myData.atomicInteger);
	} 
	public static void main2(String[] args) {
		 System.out.println("可见性测试");
	     MyData myData=new MyData();//资源类
	     new Thread(()->{
	            System.out.println(Thread.currentThread().getName()+"\t come in");
	            try {
	                TimeUnit.SECONDS.sleep(3);
	                myData.setTo60();
	                System.out.println(Thread.currentThread().getName()+"\t update number value: "+myData.number);
	            }catch (InterruptedException e)
	            {
	                e.printStackTrace();
	            }
	        },"AAA").start();
	     while (myData.number==0){
             //main线程持有共享数据的拷贝，一直为0
	     }
	     System.out.println(Thread.currentThread().getName()+"\t mission is over. main get number value: "+myData.number);
     
	}
}

myData是资源类，一开始number变量没有用volatile修饰，所以程序运行结果是

可见性测试
AAA	 come in
AAA	 update number value: 60

虽然一个线程把number修改成了60，但是main线程持有的仍然是最开始的0，所以一直循环，程序不会结束。
如果对number添加了volatile修饰，运行结果是：

AAA	 come in
AAA	 update number value: 60
main	 mission is over. main get number value: 60

不能保证原子性

volatile并不能保证操作的原子性。
比如一条number++的操作，会形成3条指令。

getfield        //读
iconst_1	//++常量1
iadd		//加操作
putfield	//写操作

假设有3个线程，分别执行number++，都先从主内存中拿到最开始的值，number=0，然后三个线程分别进行操作。假设线程0执行完毕，number=1，也立刻通知到了其它线程，但是此时线程1、2已经拿到了number=0，所以结果就是写覆盖，线程1、2将number变成1。

禁止指令重排

volatile可以保证有序性，也就是防止指令重排序。
所谓指令重排序，就是出于优化考虑，CPU执行指令的顺序跟程序员自己编写的顺序不一致。就好比一份试卷，题号是老师规定的，是程序员规定的，但是考生（CPU）可以先做选择，也可以先做填空。

经典场景就是单例模式

ackage juc;

public class SingletonDemo {
	public static SingletonDemo demo =null;
	private SingletonDemo() {
		System.out.println("构造方法");
	}
	public static SingletonDemo getInstance() {
		if(demo==null) {
			synchronized (SingletonDemo.class) {
				if(demo==null) {
					demo=new SingletonDemo();
				}
			}
		}
		return demo;
	}
	public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                SingletonDemo.getInstance();
            },String.valueOf(i+1)).start();
        }
    }
}

instance=new SingletonDemo();可以大致分为三步：

memory = allocate();     //1.分配内存
instance(memory);	 //2.初始化对象
instance = memory;	 //3.设置引用地址

其中2和3没有数据依赖关系，可能发生重排序132。如果发生，此时内存已经分配，nameinstance不为null。如果此时线程挂起，2步骤还未执行，对象还未初始化。由于instance!=null,所以两次判断都跳过，最后返回的instance没有任何内容，没有进行初始化。

valatile底层用CPU的内存屏障指令来实现的，有两个作用，一个是保证特定操作的顺序性。二是保证变量的可见性。在指令之间插入一条Memory Barrier指令，告诉编译器和CPU，在Memory Barrier指令之间的指令不能被重排序。

关于volatile内存屏障，看第二篇；volatile内存屏障
难度较高，看到这里就足够了。