- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章java中volatile关键字的作用与实例代码由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.
volatile是java虚拟机提供的轻量级同步机制 。
作用是: 1.保证可见性 2.禁止指令重排 3.不保证原子性 。
本篇具体就讲解 什么叫保证了可见性, 什么叫禁止指令重排,什么是原子性 。
而在这之前需要对JMM 有所了解 。
JMM(java 内存模型 Java Memory Model 简称JMM) 本身是一个抽象的概念,并不在内存中真实存在的,它描述的是一组规范或者规则,通过这组规范定义了程序中各个变量(实例字段,静态字段和构成数组对象的元素)的访问方式. 。
JMM的同步规定
1.线程解锁之前,必须把共享变量刷新回主存 。
2.线程加锁锁之前,必须读取主存的最新值到自己的工作空间 。
3.加锁解锁必须是 同一把锁 。
由于 JMM运行程序的实体是线程.而每个线程创建时JMM都会为其创建一个自己的工作内存(栈空间),工作内存是每个线程的私有 数据区域.而java内存模型中规定所有的变量都存储在主内存中,主内存是共享内存区域,所有线程都可以访问,但线程的变量的操作(读取赋值等)必须在自己的工作内存中去进行,首先要 将变量从主存拷贝到自己的工作内存中,然后对变量进行操作,操作完成后再将变量操作完后的新值写回主内存,不能直接操作主内存的变量,各个线程的工作内存中存储着主内存的变量拷贝的副本,因IC不同的线程间无法访问对方的工作内存,线程间的通信必须在主内存来完成, 其简要访问过程如下图
可见性:指当多个线程访问同一个变量时,一个线程修改了这个变量的值,其他线程能够立即看得到修改的值.
通过前面的 JMM介绍,我们知道各个线程对主内存的变量的操作都是各个线程各自拷贝到自己的工作内存中进行操作,然后在写回主内存中 。
这就可能存在一个线程a修改了共享变量X的值但还未写回主内存,又有一个线程b对共享变量X进行操作,但 此时线程a的工作内存的共享变量X对线程吧来说是不可见的,这种工作内存与主内存同步延迟的问题就造成了可见性问题 。
原子性:某个线程在执行某项业务时,中间不可被加塞或分割,需要整体完整。要么同时成功,要么同时失败 。
class MyData{ volatile int number = 0; Object object = new Object(); public void addTo60(){ this.number = 60; } public void addPlusPlus(){ this.number++; } AtomicInteger atomicInteger = new AtomicInteger(); public void addAtomic(){ atomicInteger.getAndIncrement(); }}/** * 验证volatile的可见性 * 1.当number未被volatile修饰时,new Thread将number值改为60,但main线程并不知道,会一直在循环中出不来 * 2.当number使用volatile修饰,new Thread改变number值后,会通知main线程主内存的值已被修改,结束任务。体现了可见性 * * 验证volatile不保证原子性 * 1.原子性是指,某个线程在执行某项业务时,中间不可被加塞或分割,需要整体完整。要么同时成功,要么同时失败 * * 如何解决呢? * 1.使用synchronize * 2.使用AtomicInteger * */public class VolatileDemo { public static void main(String[] args) { //seeByVolatile(); atomic(); } //验证原子性 public static void atomic() { MyData myData = new MyData(); for (int i = 1; i <= 20; i++) { new Thread(new Runnable() { @Override public void run() { for (int j = 1; j <= 1000; j++) { /*synchronized (myData.object){ myData.addPlusPlus(); }*/ myData.addPlusPlus(); myData.addAtomic(); } } }).start(); } //等待上面20个线程全部计算结束 while (Thread.activeCount() > 2){ Thread.yield(); } System.out.println(Thread.currentThread().getName() + "int finally number is " + myData.number); System.out.println(Thread.currentThread().getName() + "AtomicInteger finally number is " + myData.atomicInteger); } //验证可见性的方法 public static void seeByVolatile() { MyData myData = new MyData(); //第一个线程 new Thread(){ public void run(){ System.out.println(Thread.currentThread().getName() + " come in"); try { sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } myData.addTo60(); System.out.println(Thread.currentThread().getName() + " update number to " + myData.number); } }.start(); //第二个线程 main while (myData.number == 0){ } System.out.println(Thread.currentThread().getName() + "mission is over"); }}
number++在多线程下是非线程安全,不是原子性操作?
计算机在执行程序时,为了提高性能,编译器和处理 器常常会对指令做重排,一般分为一下三种
单线程的环境里指令重排确保最终执行的结果和代码顺序执行的结果一致 。
处理器在进行指令重排是必须 要考虑指令之间的数据依赖性 。
多线程的环境交替执行,由于编译器优化重排的存在,俩个线程使用变量能否保证一致性是无法确定的,无法预料的 。
实例一
实例二
线程操作资源类,线程1访问method1,线程2访问method2,正常情况顺序执行,a=6 多线程下假设出现了指令重排,语句2在语句1之前,当执行完flag=true后,另一个线程马上执行method2,a=5 。
所以volatile 禁止指令重排,从而避免多线程的 环境下出现执行乱序 的情况 。
单例DCL的代码 。
单例DCL的代码public class SingletonDemo { private static SingletonDemo instance = null; private SingletonDemo(){ System.out.println(Thread.currentThread().getName() + "构造方法"); } //DCL双端加锁机制 public static SingletonDemo getInstance(){ if (instance == null){ synchronized (SingletonDemo.class){ if (instance == null){ instance = new SingletonDemo(); } } } return instance; }}
这种写法在多线程条件下可能正确率为99.999999%,但可能由于指令重排出错 。
原因在于某一个线程执行到第一次检测,读取到instance不为null,instance引用对象可能还没有完成初始化. 。
instance = new SingletonDemo();; 分为一下三步 。
2 ,3 步不存在数据依赖, 可以指令重排的执行顺序为 1 ,3 ,2,设置instance指向刚分配的地址,次数instance还没有初始化完 。
但此时instance不为null了,若正好此时有一个线程来访问,就出现了线程安全问题 。
所以需要添加volatile 关键字 。
public class SingletonDemo { private static volatile SingletonDemo instance = null; private SingletonDemo(){ System.out.println(Thread.currentThread().getName() + "构造方法"); } //DCL双端加锁机制 public static SingletonDemo getInstance(){ if (instance == null){ synchronized (SingletonDemo.class){ if (instance == null){ instance = new SingletonDemo(); } } } return instance; }}
到此这篇关于java中volatile关键字的文章就介绍到这了,更多相关java volatile关键字内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我! 。
原文链接:https://blog.csdn.net/clinginh/article/details/115416672 。
最后此篇关于java中volatile关键字的作用与实例代码的文章就讲到这里了,如果你想了解更多关于java中volatile关键字的作用与实例代码的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
这将是一篇很长的文章,为了将其上下文化并提供尽可能多的信息,我必须仔细浏览各种链接和引号——这通常是我们进入 C/C++ 标准兔子洞的唯一方法。如果您对这篇文章有更好的引用或任何其他改进,请告诉我。但
我想知道 volatile 关键字与 register、const 和 static 结合的不同用途关键词。我不确定有什么影响,所以我认为: register volatile int T=10; 建
让我们考虑以下 Java 代码 int x = 0; int who = 1 Thread #1: (1) x++; (2) who = 2; Thread #2 while(who
有一个函数“remove_cv”(http://en.cppreference.com/w/cpp/types/remove_cv)可以删除常量和 volatile 。 我的问题是为什么可以从“con
我正在尝试在下面的“MpscQueue.h”中的嵌入式目标上实现多个生产者(通过中断)、单个消费者(通过应用程序线程)队列。 我想知道我是否可以安全地删除一些 volatile下面的用法(见内联问
我的问题适用于最初为 null 的字段,然后初始化为非 null 值,然后不再更改。 由于该字段需要尽快可供所有线程使用,因此我需要使用 volatile 。 但是,如果我想尽可能避免 volatil
我以前见过几次类似 fld = fld 的东西,但在所有这些情况下,可以消除虚拟写入并获得更好的性能。 public class Tst{ public volatile int fld =
看完this question和 this (尤其是第二个答案)我对 volatile 及其与内存屏障有关的语义感到非常困惑。 在上面的例子中,我们写入了一个 volatile 变量,这会导致一个 m
如下所示,该程序有一个共享 var flag,但不带 volatile : public class T { public static void main(String[] args) {
我明白声明 int *volatile ptr; 表示指针本身是volatile int a=10; int *volatile ptr=&a; 现在 ptr 和 a 都在更新。会不会导致访问ptr时
最近我需要比较两个 uint 数组(一个是 volatile 数组,另一个是非 volatile 数组),结果令人困惑,我一定是对 volatile 数组有一些误解。 我需要从输入设备读取一个数组并将
这两个 C 定义有什么区别? volatile uint32_t *ptr1 = (volatile uint32_t *)0x20040000; volatile uint32_t *ptr1 =
// structure is like this, but not exact formation. class queue { volatile List worksWaiting; }
考虑以下这段代码: struct S{ int i; S(int); S(const volatile S&); }; struct S_bad{ int i; }; vola
在 Windows x64 上,考虑到一些额外的见解,何时允许编译器将 ABI 标记为 volatile 的寄存器视为非 volatile 寄存器?我有一个反汇编函数,其中 r11 用于在函数调用后恢
我对下面的代码段有疑问。结果可能有 [0, 1, 0] 的结果(这是用 JCStress 执行的测试)。那么这怎么会发生呢?我认为应该在写入 Actor2 (guard2 = 1) 中的 guard2
好吧,假设我有一堆变量,其中一个声明为 volatile: int a; int b; int c; volatile int v; 如果一个线程写入所有四个变量(最后写入 v),而另一个线程读取所有
我试图理解为什么这个例子是一个正确同步的程序: a - volatile Thread1: x=a Thread2: a=5 因为存在冲突访问(存在对 a 的写入和读取),所以在每个顺序一致性执行中,
我正在编写一个需要同时支持 volatile 和非 volatile 实例的类( volatile 实例使用原子操作,非 volatile 实例使用常规操作),并且想知道我是否以正确的方式进行处理。到
我正在为 Cortex-M0 CPU 和 gcc 编写代码。我有以下结构: struct { volatile unsigned flag1: 1; unsigned flag2: 1
我是一名优秀的程序员,十分优秀!