多线程之美1一volatile

目录
1、java内存模型
1.一、抽象结构图
1.二、概念介绍
2、volatile详解
2.一、概念
2.二、保证内存可见性
2.三、不保证原子性
2.四、有序性

1、java内存模型

1.一、抽象结构图

1.二、概念介绍

• java 内存模型

  即Java memory model(简称JMM), java线程之间的通讯由JMM控制，决定一个线程对共享变量的写入什么时候对另外一个线程可见。

• 多线程通讯一般分为2类：共享内存和消息传递

  JMM采用的就是共享内存来实现线程间的通讯，且通讯是隐式的，对程序开发人员是透明的，因此在了解其原理了，才会对线程之间通讯，同步，内存可见性问题有进一步认识，避免开发中出错。

• 线程之间如何通讯？

  在java中多个线程之间要想通讯，如上图所示，每一个线程在须要操做某个共享变量时，会将该主内存中这个共享变量拷贝一份副本存在在本身的本地内存（也叫工做内存，这里只是JMM的一个抽象概念，即将其笼统看作一片内存区域，用于每一个线程存放变量，实际涉及到缓存，寄存器和其余硬件），线程操做这个副本，好比 int i = 1；一个线程想要进行 i++操做，会先将变量 i =1 的值先拷贝到本身本地内存操做，完成 i++，结果 i=2，此时主内存中的值仍是1，在线程将结果刷新到主内存后，主内存值就更新为2，数据达到一致了。
  
  若是线程A，线程B同时将 主内存中 i =1拷贝副本到本身本地内存，线程A想要 将i+1,而线程B想要将 int j=i，将赋值给j,那么如何保证线程之间的协做，此时就会涉及到线程之间的同步以及内存可见性问题了。（后文分析synchronized/lock）
   那线程之间实现通讯须要通过2个步骤，借助主内存为中间媒介：
     线程A （发送消息）-->（接收消息） 线程B  
     一、线程A将本地内存共享变量值刷新到主内存中，更新值；
     二、线程B从主内存中读取已更新过的共享变量；

• 共享内存中涉及到哪些变量称为共享变量？

  这里的共享内存指的是jvm中堆内存中，全部堆内存在线程之间共享,由于栈中存储的是方法及其内部的局部变量，不在此涉及。
  共享变量：对于多线程之间可以共同操做的变量，包含实例域，静态域，数组元素。即有成员变量，静态变量等等，
     不涉及到局部变量（因此局部变量不涉及到内存可见性问题）

• 多线程在java内存模型中涉及到三个问题

  • 可见性
  • 原子性
  • 有序性（涉及指令重排序）

2、volatile详解

2.一、概念

-一、volatile 是 java中的关键字，可修饰字段，能够保证共享变量的在内存的可见性，有序性，不保证原子性。
-二、做用：在了解java内存模型后，才能更加了解volatile在JMM中的做用，volatile在JMM中为了保证内存的可见性，便是线程之间操做共享变量的可见性。

• volatile写和读的内存语义

volatile 写的内存语义：
    当写一个volatile修饰的共享变量时，JMM会把该线程的本地内存的共享变量副本值刷新到主内存中；
volatile 读的内存语义：
    当读一个volatile修饰的共享变量时，JMM会将该线程的本地内存的共享变量副本置为无效，要求线程从新去主内存中获取最新的值。

• java内存模型控制与volatile冲突吗？什么区别？

不冲突！java内存模型控制线程工做内存与主内存之间共享变量会同步，即线程从主内存中读一份副本到工做内存，又刷新到主内存，那怎么还须要 volatile来保证可见性，不是JMM本身能控制吗，通常状况下JMM能够控制 2分内存数据一致性，可是在多线程并发环境下，虽然最终线程工做内存中的共享变量会同步到主内存，但这须要时间和触发条件，线程之间同时操做共享变量协做时，就须要保证每次都能获取到主内存的最新数据，保证看到的工做变量是最后一次修改后的值，这个JMM无法控制保证，这就须要volatile或者后文要讲的 synchronized和锁的同步机制来实现了。

2.二、保证内存可见性

• 一、多个线程出现内存不可见问题示例

  /**
   * @author zdd
   * Description: 测试线程之间，内存不可见问题
   */
  public class TestVisibilityMain {
      private static boolean isRunning = true;
  
    // 可尝试添加volatile执行，其他不变，查看线程A是否被中止
    //private static volatile boolean isRunning = true;
  
      public static void main(String[] args) throws InterruptedException {
  //1,开启线程A,读取共享变量值 isRunning，默认为true 
          new Thread(()->{
            // --> 此处用的lamda表达式，{}内至关于Thread的run方法内部需执行任务 
              System.out.println(Thread.currentThread().getName() + "进入run方法");
              while (isRunning == true) {
              }
              System.out.println(Thread.currentThread().getName()+"被中止！");
          },"A").start();
          //2，主线程休眠1s, 确保线程A先被调度执行
          TimeUnit.SECONDS.sleep(1);
      //3,主线程修改共享变量值 为flase,验证线程A是否可以获取到最新值，跳出while循环  --> 验证可见性
          isRunning =false;
          System.out.println(Thread.currentThread().getName() +"修改isRunning为: " + isRunning);
      }
  }

​ 执行结果以下图：

​

• 二、一个容易忽视的问题

上面代码 while里面是一个空循环，没有操做，若是我在里面加一句打印语句，线程A会被中止，这是怎么回事呢？
 原：while (isRunning == true) {}
 改1：
 while (isRunning == true) {
     System.out.println("进入循环");
 }
原来 println方法里面加了 synchronized关键字，在加了锁既保证原子性，也保证了可见性，会实现线程的工做内存与主内存共享变量的同步。
源代码以下：
 public void println(String x) {
        synchronized (this) {
            print(x);
            newLine();
        }
    }
  改2：
  while (isRunning == true) {
       //改成这样，也能够中止线程A
                synchronized (TestVisibilityMain.class){}
   }

2.三、不保证原子性

• 一、示例代码

/**
 * @author zdd
 * Description: 测试volatile的不具备原子性
 */
public class TestVolatileAtomic {

    private static volatile   int  number;
    //开启线程数
    private static final  int THREAD_COUNT =10;
    //执行 +1 操做
    public static void  increment() {
       //让每一个线程进行加1次数大一些，可以更容易出现volatile对复合操做（i++）没有原子性的错误
        for (int i = 0; i < 10000; i++) {
          number++;
        }
    }

    public static int getNumber() {
        return number;
    }

    public static void main(String[] args) throws InterruptedException {
        TestVolatileAtomic volatileAtomic  = new TestVolatileAtomic();
        Thread[] threads = new Thread[THREAD_COUNT];
        for (int i = 0; i < THREAD_COUNT; i++) {
            threads[i]=
            new Thread(()->{
               // 作循环自增操做
                volatileAtomic.increment();
                System.out.println(Thread.currentThread().getName() +"的number值: "+volatileAtomic.getNumber());
            },"thread-"+i);
        }

        for (int i = 0; i <10; i++) {
          //开启线程
            threads[i].start();
        }
        //主线程休眠4s，确保上面线程都执行完毕
        TimeUnit.SECONDS.sleep(4);
        System.out.println("执行完毕，number最终值为："+volatileAtomic.getNumber());
    }
}

执行结果：number的最后值不必定是 10*10000= 100000的结果

• 二、缘由分析

对单个volatile变量的读/写具备原子性，而对像 i++这种复合操做不具备原子性。
上面代码 i++操做能够分为3个步骤
-1 先读取变量i的值   i
-2 进行i+1操做   temp= i+1
-3 修改i的值     i= temp
好比：好比在线程A，B同时去操做共享变量i, i的初始值为10，A，B同时去获取i的值，A对i进行 temp =i+1，此时i的值还没变， 线程B也对i进行 temp=i+1了，线程A执行i=temp的操做，i的值变为11，此时因为 volatile可见性，会刷新A的 i值到主内存，主内存中i此时也更新为11了，线程B接收到通知本身i无效了，从新读取i=11,虽然i=11，可是已经进行过 temp= i+1了，此时temp =11，线程B继续第三步，i=temp =11, 预期结果是i被A，B自增各一次，结果i=12，如今为11，出现数据错误。

2.四、有序性

• 重排序

-1,重排序概念：重排序是编译器和处理器为了优化程序性能而对指令序列从新排序的一种手段
即：程序员编写的程序代码的顺序，在实际执行的时候是不同的，这其中编译器和处理器在不影响最终执行结果的基础上会作一些优化调整，有从新排序的操做，为了提升程序执行的并发性能。
-2,重排序分类： 编译重排序，处理器重排序
-4,单线程下，重排序没有问题，可是在多线程环境下，可能会破坏程序的语义.

• volatile 防止重排序保证有序性

为了实现volatile的内存语义，JMM会限制编译器和处理器重排序

-1 制定了重排序规则表编译器防止编译器重排序

volatile重排序规则表（图摘自书-并发编程的艺术）

-2 插入内存屏障防止处理器重排序

参考资料： 一、Java并发编程的艺术- 方腾飞 二、java多线程编程核心技术- 高洪岩