Java多线程之内存可见性

Wesley13
• 阅读 532

Java多线程之内存可见性

一、Java内存模型介绍

什么是JMM?

Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则,以及在JVM中将变量存储到内存和从内存中读取出变量这样的细节

所有的变量都存储在主内存中

每个线程都有自己独立的工作内存,里面保存该线程使用到的变量的副本(主内存中该变量的一份拷贝)

如下图所示:

Java多线程之内存可见性

两条规定

线程对共享变量的所有操作必须在自己的工作内存中进行,不能直接从主内从中读写

不同线程之间无法直接访问其他线程工作内存中的变量,线程间变量值得传递需要通过主内存来完成。

那么什么是共享变量?

如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量

二、可见性介绍

什么是可见性?

一个线程对共享变量的修改,能够及时地被其他线程看到。

实现共享变量可见性的前提

线程修改后的共享变量能够及时的从工作内存中刷新到主内存中

其他线程能够及时把共享变量的最新值从主内存中更新到自己的工作内存中

共享变量可见性的实现原理

如图所示,线程1对共享变量的修改要想被线程2及时看到,必须要经过如下两个步骤:

①把工作内存1中更新过的共享变量刷新到主内存中

②将主内存中最新的共享变量的值更新到工作内存2中

Java多线程之内存可见性

什么是指令重排序?

代码书写的顺序与实际执行的顺序不同,指令重排序是编译器或处理器为了提高程序的性能而做的优化

①编译器优化的重排序(编译器优化)

②指令级并行重排序(处理器优化)

③内存系统的重排序(处理器优化)

as-if-serial语义

无论如何重排序,程序执行的结果应该与代码顺序结果一致(Java编译器运行时和处理器都会保证Java在单线程下遵循as-if-serial语义)

如下三行代码:

int num = 1;       //第一行代码

int num2 = 2;       //第二行代码

int sum = num1 + num2;  //第三行代码

单线程:第1、2行的顺序可以重排,但第三行不能

重排序不会给内存带来可见性问题

多线程中程序交错执行时,重排序可能会造成内存可见性问题

导致共享变量在线程间不可见的原因:

①线程的交叉执行

②重排序结合线程交叉执行

③共享变量更新后的值没有在工作内存中与主内存间及时更新

可见性的实现方式:

JAVA语言层面支持的可见性的实现方式:

①synchronized

②volatile

三、synchronized实现可见性

synchronized实现可见性

原子性(同步)、可见性,如下表格

不可见的原因

synchronized解决方案

线程的交叉执行

原子性

重排序结合线程交叉执行

原子性

共享变量未及时更新

可见性

JMM关于synchronized的两条规定

①线程解锁前,必须把共享变量的最新值刷新到主内存中

②线程加锁时,将清空工作内存中共享变量的值,从而使用共享变量时需要从主内存中重新读取最新的值(注意:加锁与解锁需要是同一把锁)

总而言之,也就是线程解锁前对共享变量的修改在下次加锁时对其他线程可见

线程执行互斥代码的过程

①获得互斥锁

②清空工作内存

③从主内存拷贝变量的的最新副本到工作内存中

④执行代码

⑤将更改后的共享变量的值刷新到主内存中

⑥释放互斥锁

代码分析

Java多线程之内存可见性 Java多线程之内存可见性

 1 package me.demo.memoryModel;
 2 
 3 public class SynchronizedDemo {
 4     // 共享变量
 5     private boolean ready = false;
 6     private int result = 0;
 7     private int number = 1;
 8 
 9     // 写操作
10     public void write() {
11     ready = true; // 1.1
12     number = 2; // 1.2
13     }
14 
15     // 读操作
16     public void read() {
17     if (ready) { // 2.1
18         result = number * 3; // 2.2
19     }
20     System.out.println("result的值为:" + result);
21     }
22 
23     // 内部线程类
24     private class ReadWriteThread extends Thread {
25     // 根据构造方法中传入的flag参数,确定线程执行读操作还是写操作
26     private boolean flag;
27 
28     public ReadWriteThread(boolean flag) {
29         this.flag = flag;
30     }
31 
32     @Override
33     public void run() {
34         if (flag) {
35         // 构造方法中传入true,执行写操作
36         write();
37         } else {
38         // 构造方法中传入false,执行读操作
39         read();
40         }
41     }
42     }
43 
44     public static void main(String[] args) {
45     SynchronizedDemo synDemo = new SynchronizedDemo();
46     // 启动线程执行写操作
47     synDemo.new ReadWriteThread(true).start();
48     try {
49         Thread.sleep(1000);
50     } catch (InterruptedException e) {
51         e.printStackTrace();
52     }
53     // 启动线程执行读操作
54     synDemo.new ReadWriteThread(false).start();
55     }
56 }

View Code

如上代码,main方法中,也就是主线程中先后启动我们模拟的写操作和读操作,中间当前执行的线程休眠1秒,我们在给write方法和read方法没有加synchronized修饰之前,也就是没有加锁之前,由于写线程和读线程相继争用CPU资源,read或write方法的执行可能不是由一个线程来完整的完成的,这就造成对于三个共享变量ready,result和number的值的改变的随机性和不确定性,这样很容易导致共享变量不可见,因而read方法打印的result的值可能是0或其他值(正常情况下打印结果是6)

如果加上synchronized修饰,也就是给write和read方法加上锁,也就是保证了共享变量的原子性和可见性,控制台会打印正常结果。

四、volatile实现可见性

volatile关键字:

能够保证volatile变量的可见性,不能保证volatile变量复合操作的原子性

例如:定义一个int型变量number;并执行number++;显然number++不是原子操作

大概可分为这三个步骤:读取number的值,将number的值加1,写入最新的number的值。

如下表格所示:

关键字

volatile

synchronized

实现方式

private volatile int number = 0;

number ++;

private int number = 0;

synchronized(this){

number++;

}

是否保证可见性

是否保证原子性

即volatile变量,无法保证原子性,加入synchronized变为原子操作

volatile如何实现内存可见性?

①深入来说:通过加入内存屏障和禁止重排序优化来实现的:

对volatile变量执行写操作时,会在写操作后加入一条store屏障指令

对volatile变量执行读操作时,会在读操作前加入一条load屏障指令

②通俗地讲:volatile变量在每次被线程访问时,都强迫从主存中重读该变量的值,而当该变量发生变化时,又会强迫线程将最新的值刷新到主内存。这样任何时刻,不同的变量总能看到该变量的最新值

线程写volatile变量的过程

①改变线程工作内存中volatile变量副本的值

②将改变后的副本的值从工作内存中刷新到主内存

线程读volatile变量的过程

①从主内存中读取volatile变量的最新值到线程的工作内存中

②从工作内存中读取volatile变量的副本

volatile适用场合

要在多线程中安全的使用volatile变量,必须同时满足:

①对变量的写入操作不依赖当前的值

不满足:number++、count = count*5等

满足:Boolean变量、记录温度变化的变量等

②该变量没有包含在具有其他变量的不变式中,即一个表达式中不能同时含有两个或两个以上的volatile变量。

不满足:不变式low<up

例如这里面有两个VOLATILE变量,它包含了一个不变式就是LOW<UP( if (value > upper) 和   if (value < low) )

public class A {

private volatile int low=0;

private volatile int up=100;

public int getLow() { return low; }

public int getUp() { return up; }

public void setLow(int value) {

if (value > upper)

system.out.print(".......");

low = value;

}

public void setUp(int value) {

if (value < low)

system.out.print(".......");

up = value;

}

}

初始值是0和100,如果有两个线程同时操作set函数,一比如A线程操作setlow(4),B线程setup(3),最后结果是4和3。

代码分析

Java多线程之内存可见性 Java多线程之内存可见性

 1 package me.demo.vol;
 2 
 3 import java.util.concurrent.locks.Lock;
 4 import java.util.concurrent.locks.ReentrantLock;
 5 
 6 public class VolatileDemo {
 7 
 8     /**
 9      * 第一种方案
10      * private volatile int number = 0; 
11      * volatile只能保证number的可见性
12      * 不能保证number++操作的原子性
13      */
14     private int number = 0;
15     
16     /**
17      * 第三种方案:
18      * 使用jdk1.5新特性
19      */
20     private Lock lock = new ReentrantLock();
21 
22     public int getNumber() {
23     return number;
24     }
25 
26     /**
27      * 第二种方案:
28      * 用synchronized关键字保证number变量在线程中的可见性 
29      * 也保证了number++操作的原子性
30      */
31     public void increase() {
32     try {
33         Thread.sleep(100);
34     } catch (InterruptedException e) {
35         e.printStackTrace();
36     }
37     /**
38      * 缩小锁的粒度
39      * synchronized (this) {
40      *  this.number++;
41      * }
42      */
43     //和synchronized的效果一样
44     lock.lock();
45     try {
46         this.number++;
47     } finally {
48         lock.unlock();
49     }
50     }
51 
52     public static void main(String[] args) {
53     VolatileDemo volatileDemo = new VolatileDemo();
54     for (int i = 0; i < 500; i++) {
55         new Thread(new Runnable() {
56         @Override
57         public void run() {
58             volatileDemo.increase();
59         }
60         }).start();
61     }
62     /**
63      * 如果还有子线程在运行,主线成就让出CPU资源 直到所有的子线程都运行完了,主线程再继续往下执行
64      */
65     while (Thread.activeCount() > 1) {
66         Thread.yield();
67     }
68     System.out.println("number:" + volatileDemo.getNumber());
69     }
70 }

View Code

  要说的都在代码注释中了,大家可根据运行结果详细分析(今天实在太累了,以后在做补充吧,有什么问题欢迎评论区留言)

五、总结

volatile和synchronized两种方式实现可见性的对比

①volatile不需要加锁,比synchronized更轻量级,不会阻塞线程;

②从内从可见性角度讲,volatile读相当于加锁,volatile写相当于解锁

③synchronized即可保证可见性,又能保证原子性,而volatile只能保证可见性,无法保证原子性。

大家可能出现的的疑问

①为什么即使没有保证可见性的措施,很多时候共享变量依然能够在主内存和工作内存中见得到及时更新?

一般只有在短时间内高并发的情况下才会出现变量得不到及时更新的情况,因为CPU在执行时会很快的刷新缓存,所以一般情况下很难看到这种问题。

②对64为(long,double)变量的读写可能不是原子操作?

Java内存模型允许JVM将没有被volatile修饰的64位数据类型的读写操作划分为两次32位的读写操作来执行

导致问题:有可能会出现读到“半个变量”得情况(大多情况下JVM将这个问题作了优化)

解决方法:加volatile关键字

③那么问题就来了,在之前讲解中,volatile变量并不能保证原子性,为何对64位变量通过加volatile关键字来保证原子操作呢?

volatile本身不保证获取和设置操作的原子性,仅仅保持修改的可见性,但是Java内存模型保证声明为volatile的long和double变量的get和set操作是原子的。

如果,您对我的这篇博文有什么疑问,欢迎评论区留言,大家互相讨论学习。
如果,您认为阅读这篇博客让您有些收获,不妨点击一下右下角的【推荐】。
如果,您希望更容易地发现我的新博客,不妨点击一下左下角的【关注我】。
如果,您对我的博文感兴趣,可以关注我的后续博客,我是【AlbertRui】。

转载请注明出处及链接地址,欢迎转载!

点赞
收藏
评论区
推荐文章
blmius blmius
2年前
MySQL:[Err] 1292 - Incorrect datetime value: ‘0000-00-00 00:00:00‘ for column ‘CREATE_TIME‘ at row 1
文章目录问题用navicat导入数据时,报错:原因这是因为当前的MySQL不支持datetime为0的情况。解决修改sql\mode:sql\mode:SQLMode定义了MySQL应支持的SQL语法、数据校验等,这样可以更容易地在不同的环境中使用MySQL。全局s
待兔 待兔
1星期前
手写Java HashMap源码
HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程HashMap的使用教程22
Wesley13 Wesley13
2年前
Java 内存模型
什么是Java内存模型?JMM(JavaMemoryModel,Java内存模型),它定义了多线程访问Java内存的规范。简单的说有以下几部分内容:Java内存模型将内存分为主内存和工作内存定义了几个原子操作,用于操作主内存和工作内存中的变量定义了volatile变量的使用规则happensbefor
Stella981 Stella981
2年前
KVM调整cpu和内存
一.修改kvm虚拟机的配置1、virsheditcentos7找到“memory”和“vcpu”标签,将<namecentos7</name<uuid2220a6d1a36a4fbb8523e078b3dfe795</uuid
Easter79 Easter79
2年前
Twitter的分布式自增ID算法snowflake (Java版)
概述分布式系统中,有一些需要使用全局唯一ID的场景,这种时候为了防止ID冲突可以使用36位的UUID,但是UUID有一些缺点,首先他相对比较长,另外UUID一般是无序的。有些时候我们希望能使用一种简单一些的ID,并且希望ID能够按照时间有序生成。而twitter的snowflake解决了这种需求,最初Twitter把存储系统从MySQL迁移
Wesley13 Wesley13
2年前
00:Java简单了解
浅谈Java之概述Java是SUN(StanfordUniversityNetwork),斯坦福大学网络公司)1995年推出的一门高级编程语言。Java是一种面向Internet的编程语言。随着Java技术在web方面的不断成熟,已经成为Web应用程序的首选开发语言。Java是简单易学,完全面向对象,安全可靠,与平台无关的编程语言。
Wesley13 Wesley13
2年前
JAVA内存模型与线程以及volatile理解
Java内存模型是围绕在并发过程中如何处理原子性、可见性、有序性来建立的。一、主内存与工作内存  Java内存模型主要目标是在虚拟机中将变量存储到内存和从内存中取出变量。这里的变量包括:实例字段、静态字段、构成数组对象的元素;不包括局部变量和方法参数,因为它们是线程私有的。Java内存模型规定了所有变量都存储在主内存,线程的工作内
Wesley13 Wesley13
2年前
MySQL部分从库上面因为大量的临时表tmp_table造成慢查询
背景描述Time:20190124T00:08:14.70572408:00User@Host:@Id:Schema:sentrymetaLast_errno:0Killed:0Query_time:0.315758Lock_
Python进阶者 Python进阶者
6个月前
Excel中这日期老是出来00:00:00,怎么用Pandas把这个去除
大家好,我是皮皮。一、前言前几天在Python白银交流群【上海新年人】问了一个Pandas数据筛选的问题。问题如下:这日期老是出来00:00:00,怎么把这个去除。二、实现过程后来【论草莓如何成为冻干莓】给了一个思路和代码如下:pd.toexcel之前把这
待兔 待兔
1星期前
Java内存的可见性
Java内存的可见性可见性:一个线程对共享变量的修改,能够及时被其它线程看到共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量Java内存模型(JMM):描述了Java程序中各种线程共享变量的访问规则,以及在JVM