结合Java内存模型理解volatile（笔记三）

最新推荐文章于 2023-07-09 09:00:00 发布

偶尔失联

最新推荐文章于 2023-07-09 09:00:00 发布

阅读量127

点赞数

分类专栏：笔记文章标签：线程安全 java

本文链接：https://blog.csdn.net/weixin_45747713/article/details/118770775

版权

笔记专栏收录该内容

4 篇文章 1 订阅

订阅专栏

参考文档
http://cmsblogs.com/?p=14869
http://cmsblogs.com/?p=14743

文章目录

一、Java内存模型
二、并发编程中的三个概念？
三.深入剖析volatile关键字
四.使用volatile关键字的场景
- 1.用volatile必须具备的2个条件
- 2.场景代码

一、Java内存模型

1 工作内存与主内存

Java内存模型定义了程序中各个变量的访问规则。Java线程与内存的关系就好比处理器与内存的关系，每个Java线程独自享有本地工作内存，通过直接对工作内存中的变量进行读写操作来平衡Java线程运算和数据存储的巨大速度差异；而主内存中的变量是共享的，定义各个变量的访问规则也是为了使得程序变量能够满足一致性，运行能够得到所期望的结果。

不同线程无法访问彼此的工作内存，消息的传递只能通过主存来进行。
在这里插入图片描述

2.内存间的交互操作

在这里插入图片描述

Java内存模型定义了以下八种操作来完成：

lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。
如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作，如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

不允许read和load、store和write操作之一单独出现
不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现
如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

3.指令重排序

一般来说，处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。

在执行程序时为了提高性能，编译器和处理器经常会对指令进行重排序。重排序分成三种类型：

编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，可以重新安排语句的执行顺序。
指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
内存系统的重排序。由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

二、并发编程中的三个概念？

在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。

1.原子性

原子性：即一个操作或者多个操作要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

x= 10;         //语句1
y=x;         //语句2
x++;           //语句3
x=x+ 1;     //语句4

只有语句1是原子性操作，其他三个语句都不是原子性操作。

语句1是直接将数值10赋值给x，也就是说线程执行这个语句的会直接将数值10写入到工作内存中
。
语句2实际上包含2个操作，它先要去读取x的值，再将x的值写入工作内存，虽然读取x的值以及将x的值写入工作内存这2个操作都是原子性操作，但是合起来就不是原子性操作了。

同样的，x++和 x = x+1包括3个操作：读取x的值，进行加1操作，写入新的值。

只有简单的读取、赋值（而且必须是将数字赋值给某个变量，变量之间的相互赋值不是原子操作）才是原子操作。

2.可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。　
　
对于可见性，Java提供了volatile关键字来保证可见性。当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。

int i= 0;i= 10; //线程1执行的代码
j=i;//线程2执行的代码

假若执行线程1的是CPU1，执行线程2的是CPU2。
当线程1执行 i =10这句时，会先把i的初始值加载到CPU1的高速缓存中，然后赋值为10，那么在CPU1的高速缓存当中i的值变为10了，却没有立即写入到主存当中。

3.有序性

有序性：即程序执行的顺序按照代码的先后顺序执行。举个简单的例子，看下面这段代码：

int i= 0;             
boolean flag= false;i= 1;                //语句1
flag= true;          //语句2

从代码顺序上看，语句1是在语句2前面的，那么JVM在真正执行这段代码的时候会保证语句1一定会在语句2前面执行吗？不一定，为什么呢？这里可能会发生指令重排序

语句1和语句2谁先执行对最终的程序结果并没有影响，那么就有可能在执行过程中，语句2先执行而语句1后执行。

但是要注意，虽然处理器会对指令进行重排序，但是它会保证程序最终结果会和代码顺序执行结果相同，那么它靠什么保证的呢？再看下面一个例子：

int a= 10;    //语句1
int r= 2;    //语句2
a=a+ 3;    //语句3
r=a*a;     //语句4

不可能是这个执行顺序呢：语句2 语句1 语句4 语句3
因为处理器在进行重排序时是会考虑指令之间的数据依赖性，如果一个指令Instruction 2必须用到Instruction 1的结果，那么处理器会保证Instruction 1会在Instruction 2之前执行。

//线程1:
context=loadContext();   //语句1
inited= true;             //语句2
 //线程2:
 while(!inited){  sleep()}doSomethingwithconfig(context);

上面代码中，由于语句1和语句2没有数据依赖性，因此可能会被重排序。
假如发生了重排序，在线程1执行过程中先执行语句2，而此是线程2会以为初始化工作已经完成，那么就会跳出while循环，去执行doSomethingwithconfig(context)方法，而此时context并没有被初始化，就会导致程序出错。
指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性。

在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）

另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么它们就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。
happens-before原则（先行发生原则）：

程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作
锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作
volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作
传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C
线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作
线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生
线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行
对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始

这8条原则摘自《深入理解Java虚拟机》。

这8条规则中，前4条规则是比较重要的，后4条规则都是显而易见的。

第二条规则也比较容易理解，也就是说无论在单线程中还是多线程中，同一个锁如果出于被锁定的状态，那么必须先对锁进行了释放操作，后面才能继续进行lock操作。

第三条规则是一条比较重要的规则，也是后文将要重点讲述的内容。直观地解释就是，如果一个线程先去写一个变量，然后一个线程去进行读取，那么写入操作肯定会先行发生于读操作。

第四条规则实际上就是体现happens-before原则具备传递性。

4.小结

想并发程序正确地执行，必须要保证原子性、可见性以及有序性。只要有一个没有被保证，就有可能会导致程序运行不正确。

三.深入剖析volatile关键字

1.volatile关键字的两层语义

保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
禁止进行指令重排序。

使用有序性介绍的的例子

//线程1:context=loadContext();   //语句1
inited= true;             //语句2
 //线程2:while(!inited){  sleep()}doSomethingwithconfig(context);

用volatile修饰之后就变得不一样

使用volatile关键字会强制将修改的值立即写入主存；
使用volatile关键字的话，当线程2进行修改时，会导致线程1的工作内存中缓存变量stop的缓存行无效（反映到硬件层的话，就是CPU的L1或者L2缓存中对应的缓存行无效）；
由于线程1的工作内存中缓存变量stop的缓存行无效，所以线程1再次读取变量stop的值时会去主存读取。

那么在线程2修改stop值时（当然这里包括2个操作，修改线程2工作内存中的值，然后将修改后的值写入内存），会使得线程1的工作内存中缓存变量stop的缓存行无效，然后线程1读取时，发现自己的缓存行无效，它会等待缓存行对应的主存地址被更新之后，然后去对应的主存读取最新的值。那么线程1读取到的就是最新的正确的值。

2.volatile不能保证原子性

public class Test{    
public volatile int inc= 0;       
  public void increase(){        inc++;    }    
       public static void main(String[]args){     
          final Testtest= new Test();      
            for(int i=0;i<10;i++){        
                new Thread(){              
                  public void run(){                  
                    for(int j=0;j<1000;j++)    {
                      test.increase();      
               											     }                 
                       				   };           
                           }.start();      
                       }                
                     while(Thread.activeCount()>1)  //保证前面的线程都执行完         
                     Thread.yield();        
                     System.out.println(test.inc); 
                }

运行它会发现每次运行结果都不一致，都是一个小于10000的数字。这里面就有一个误区了，volatile关键字能保证可见性没有错，但是上面的程序错在没能保证原子性。可见性只能保证每次读取的是最新的值，但是volatile没办法保证对变量的操作的原子性。

自增操作是不具备原子性的，它包括读取变量的原始值、进行加1操作、写入工作内存。那么就是说自增操作的三个子操作可能会分割开执行，就有可能导致下面这种情况出现：

某个时刻变量inc的值为10，线程1对变量进行自增操作，线程1先读取了变量inc的原始值，然后线程1被阻塞了;然后线程2对变量进行自增操作，线程2也去读取变量inc的原始值.

由于线程1只是对变量inc进行读取操作，而没有对变量进行修改操作，所以不会导致线程2的工作内存中缓存变量inc的缓存行无效，所以线程2会直接去主存读取inc的值，发现inc的值时10，然后进行加1操作，并把11写入工作内存，最后写入主存。

然后线程1接着进行加1操作，由于已经读取了inc的值，注意此时在线程1的工作内存中inc的值仍然为10，所以线程1对inc进行加1操作后inc的值为11，然后将11写入工作内存，最后写入主存。

那么两个线程分别进行了一次自增操作后，inc只增加了1。线程1对变量进行读取操作之后，被阻塞了的话，并没有对inc值进行修改。然后虽然volatile能保证线程2对变量inc的值读取是从内存中读取的，但是线程1没有进行修改，所以线程2根本就不会看到修改的值。

//a++等价于
  public void add() {   
        temp = a;        
        temp = temp +1;  
        a = temp;         
    }

比如A线程取出a的值，但B线程在A写回++的a前也取出了旧的a值，那么两次更新后 a 仅增加了1。
volatile 变量的写被保证是可以被之后其他线程的读看到的，因此我们可以利用它进行线程间的通信。

    volatile int a;
    public void set(int b) {
        a = b; 
    }
    public void get() {    
        int i = a; 
    }

线程A执行set()后，线程B执行get()，相当于线程A向线程B发送了消息。
自增操作不是原子性操作，而且volatile也无法保证对变量的任何操作都是原子性的。volatile并不能保证复合操作的一致性，它仅保证原子操作的一致性。

3.volatile能保证有序性

volatile关键字能禁止指令重排序，所以volatile能在一定程度上保证有序性。
　volatile关键字禁止指令重排序有两层意思：

当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行；
在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

//x、y为非volatile变量
//flag为volatile变量 
x= 2;        //语句1
y= 0;        //语句2
flag= true;  //语句3
x= 4;         //语句4
y=-1;       //语句5

由于flag变量为volatile变量，那么在进行指令重排序的过程的时候，
不会将语句3放到语句1、语句2前面，也不会讲语句3放到语句4、语句5后面。
但是要注意语句1和语句2的顺序、语句4和语句5的顺序是不作任何保证的。

并且volatile关键字能保证，执行到语句3时，语句1和语句2必定是执行完毕了的，
且语句1和语句2的执行结果对语句3、语句4、语句5是可见的。

回到前面举的一个例子

//线程1:
context=loadContext();   //语句1
inited= true;             //语句2
 //线程2:
 while(!inited){  sleep()}doSomethingwithconfig(context);

提到有可能语句2会在语句1之前执行，那么久可能导致context还没被初始化，
而线程2中就使用未初始化的context去进行操作，导致程序出错。
这里如果用volatile关键字对inited变量进行修饰，就不会出现这种问题了，
因为volatile能保证有序性,当执行到语句2时，必定能保证context已经初始化完毕。

4.volatile能保证可见性

对于可见性，Java提供了volatile关键字来保证可见性。

当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。

被修改后的变量会立即刷入共享内存
处理器为了提高速度，不会和内存直接通讯，而将共享内存变量拷贝到自己的缓存中进行操作，但操作完之后又不知何时写回，所以如果声明了volatile就可以保证变量在修改后立即写回。
这个写回的操作会导致其他缓存该内存地址的数据无效
当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作的时候，会强制重新从系统内存里把数据读到处理器缓存里。一个处理器的缓存回写到内存会导致其他处理器的缓存无效。

四.使用volatile关键字的场景

synchronized关键字是防止多个线程同时执行一段代码，那么就会很影响程序执行效率，而volatile关键字在某些情况下性能要优于synchronized，volatile关键字是无法替代synchronized关键字，因为volatile关键字无法保证操作的原子性。

1.用volatile必须具备的2个条件

对变量的写操作不依赖于当前值
该变量没有包含在具有其他变量的不变式中

2.场景代码

状态标记量

volatile boolean flag= false; 
while(!flag){    doSomething();} 
public void setFlag(){    flag= true;}

volatile boolean inited= false;
//线程1:
context=loadContext();
inited= true;          
//线程2:
while(!inited){
	sleep()}
doSomethingwithconfig(context);

double check

class Singleton{  
private volatile static Singletoninstance= null;
private Singleton(){}        
 public static SingletongetInstance(){  
       if(instance==null){    
               synchronized (Singleton.class){   
                            if(instance==null)  {
								  instance= new Singleton();  
											}                         
 										}
         						} 
                return instance;   
                   		}
              }