java 关于volatile读操作与volatile修饰引用类型变量的问题? [问题点数:40分]

Bbs1
本版专家分:0
结帖率 33.33%
Bbs5
本版专家分:2039
Blank
黄花 2017年3月 Java大版内专家分月排行榜第二
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs4
本版专家分:1410
Bbs1
本版专家分:0
Java中Volatile 修饰
Java中Volatile <em>修饰</em>符今天我们来学习 Volatile <em>修饰</em>符 <em>关于</em>这个<em>修饰</em>符 我学习了两次 每次都记不住 各种查文档 看大神博客 才了解一点,我们来看看 这个<em>修饰</em>符的作用。下面是摘自 http://www.cnblogs.com/zhengbin/p/5654805.html 郑州文武对 可见性 和原子性的理解可见性:  可见性是一种复杂的属性,因为可见性中的错误总是会违背我们
对Volatile变量的理解和总结
之前因为对Volatile变量的理解不够深刻,只是知道它可以轻量级的锁,但是在真正编写多线程的程序时,除用它来做为线程结束的标志外,并不敢过多的使用。但是在看Current包中的大部分源码时发现,作者居然使用Volatile变量加CAS操作实现了很多只有通过加锁才能实现的功能,叹为观止。然后就在前面了解了JMM的基础上,又去详细的了解了一下Volatile变量的使用。 <em>volatile</em>变量的读写对所
volatile能保证long&double类型变量操作的原子性
这个题是正确的,但是也不是必须的。该命题的存在是Java内存模型要求lock, unlock, read, load, assign, use, write这个8个操作都具有原子性,但是同时又对64位的数据类型(long&double)给了一个相对宽松的规定,就是允许虚拟机将没有被<em>volatile</em>参数<em>修饰</em>的64位数据类型的读写划分为两次32位的操作来进行,即允许虚拟机将load, store, r
volatile变量与普通变量的区别
Java团长 2017-10-06 22:46 我们通常会用<em>volatile</em>实现一些需要线程安全的代码(也有很多人不敢用,因为不了解),但事实上<em>volatile</em>本身并不是线程安全的,相对于synchoronized,它有更多的使用局限性,只能限制在某些特定的场景。本篇文章的目的就是让大家对 <em>volatile</em> 在本质上有个把握,为了达到这个目的,我们会从<em>java</em> 的内存模型及变量操作的内存
java中的volatile关键字的功能详解
Cookie的应用场景: 1,记录用户的登陆状态,提示用户是否记住密码; 2,购物车购物功能; 我们知道,在web开发过程中,我们都要和cookie打交道,有时候离开了cookie还真玩不转。cookie最典型的应用莫过于登陆提示,最近在做一个小项目,正好要用到cookie的知识,在这里顺便做一下总结。
【并发】volatile是否能保证数组中元素的可见性?
  <em>问题</em>   一个线程向<em>volatile</em>的数组中设置值,而另一个线程向<em>volatile</em>的数组中读取。 比如seg.setValue(2),随后另一个线程调用seg.getValue(2),前一个线程设置的值对读取的线程是可见的吗? 我看书上说<em>volatile</em>的数组只针对数组的<em>引用</em>具有<em>volatile</em>的语义,而不是它的元素。   对一个共享变量使用Volatile关键字保证了线程间对该数...
Java并发编程-正确理解volatile关键字的两层语义
<em>关于</em>关键字<em>volatile</em>可以说是Java虚拟机提供的轻量级的同步机制,但是它并不容易完全被正常、完整地理解,以至于许多程序员都不习惯去使用它,遇到需要处理多线程数据竞争<em>问题</em>的时候一律使用Synchronized来进行同步。了解<em>volatile</em>变量的语义对了解多线程操作的其他特性很有意义。本篇文章将结束<em>volatile</em>关键字的两类语义:可见性和禁止指令重拍序。 1.volatil
彻底明白volatile关键字
一,基本概念1,CPU多核时代的到来,引入了著名的缓存一致性<em>问题</em>。(通常称这种被多个线程访问的变量为共享变量)。硬件层面有两个方案,一是对总线加LOCK,禁止别的CPU访问;二是MESI协议(如果发现操作的变量是共享变量,即在其他CPU中也存在该变量的副本,会发出信号通知其他CPU将该变量的缓存行置为无效状态,因此当其他CPU需要读取这个变量时,发现自己缓存中缓存该变量的缓存行是无效的,那么它就会...
volatile变量类型的详细说明
关键字<em>volatile</em>是<em>java</em>虚拟机提供的最轻量级的同步机制
java中Volatile修饰符的含义
在<em>java</em>语言中:为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值进行对比。         <em>volatile</em>关键字的作用就是提示vm:对于这个成员变量不能保存它的私有拷贝,而应直接与共享变量进行交互。         被<em>volatile</em><em>修饰</em>符<em>修饰</em>的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成
volatile变量详解
一、可见性 二、禁止重排序 三、<em>java</em>内存模型对<em>volatile</em>的特殊规则 关键字<em>volatile</em>可以说是Java虚拟机提供的最轻量级的同步机制,但是它并不容易完全被正确、 完整地理解,以至于许多程序员都习惯不去使用它,遇到需要处理多线程数据竞争<em>问题</em>的时候一律使用synchronized来进行同步。 当一个变量定义为<em>volatile</em>之后,它将具备两种特性:一是可见性,二是会禁...
关于volatile对变量自增不保证原子性的原因所产生的疑问。
在多线程情况下,有i变量: <em>volatile</em> int i = 0; 这种情况下,如果多线程对i进行自增操作:i++,结果可能会与预期值不同,这是什么原因呢? 先来看看大多人对这一错误的解释: 是因为<em>volatile</em>不能保证原子性,而i++其实有三步操作,读,修改,写,并不是原子操作,所以<em>volatile</em>当然不能保证结果的准确性,解释完毕! 其实博主我觉得这种解释相当的流氓 让我想起
Java关键字volatile修饰变量
<em>volatile</em>关键字的作用是告诉编译器,凡是被该关键字申明的变量都是易变的、不稳定的,所以不要试图对该变量使用缓存等优化机制,而应当每次都从他的内存地址中去读取值,但<em>volatile</em>并不是每次更改完就要立刻将他写回内存,<em>volatile</em>只提供了内存的可见性,并不提供原子性(与锁机制的区别:锁机制即提供了内存的可见性又提供了原子性)。   使用<em>volatile</em>标记的变量在读取或写入时不需要使用锁,
volatile和重排序得一些小疑问
http://yeziwang.iteye.com/blog/1042492  好吧,这里我只想说说<em>volatile</em>在JMM中的语义。     当我们在使用<em>volatile</em>的时候,实际上它表达了下面那么些意思。      1. 可见性。       这个是大多数人都知道的一个特质, JAVA的线程有自己的工作内存区,与主存区不同,当我们对变量使用了<em>volatile</em>后,那么不管对这个...
java中的Volatile关键字(成员变量修饰符)
Volatile<em>修饰</em>的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。 Java语言规范中指出:为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。 这样当多个线程同时与某个对象交
【Java并发编程】之五:volatile变量修饰符—意料之外的问题(含代码)
在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的。而随着JVM的成熟和优化,现在在多线程环境下<em>volatile</em>关键字的使用变得非常重要。 在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。 要解决这个<em>问题</em>,就需要把变量声明为<em>volatile</em>(不稳定的),这就指示JVM,这个变量是不稳
java属性为什么不能同时被final volatile 修饰
<em>volatile</em>是一个类型<em>修饰</em>符,它是被设计用来<em>修饰</em>被不同线程访问和修改的变量,可以被异步的线程所修改。 <em>volatile</em><em>修饰</em>的变量是放到共享内存中的,可以让所有的线程获取和修改。 final必须对它赋予初值并且不能修改它。...
Java中 volatile关键字怎么禁止重排序
使用<em>volatile</em>关键字<em>修饰</em>共享变量可以禁止重排序。若用<em>volatile</em><em>修饰</em>共享变量,在编译时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序   <em>volatile</em>禁止指令重排序的一些规则:   1.当第二个操作是voaltile写时,无论第一个操作是什么,都不能进行重排序   2.当地一个操作是<em>volatile</em>读时,不管第二个操作是什么,都不能进行重排序   3.当第一个操作是
C基础,计算机中的数以及volatile限定修饰符,指针及其注意事项,external,static,Void *
在C语言中可以用<em>volatile</em>限定符<em>修饰</em>变量,就是告诉编译器,即使在编译时指定了优化选项,每次读这个变量仍然要老老实实从内存读取,每次写这个变量也仍然要老老实实写回内存,不能省略任何步骤。
关于全局变量被修改以及volatile的用法
..... unsigned char num=0; ..... INTERRUPT() { .... num++; .... } void main() { out(num); } 很不幸的事情是在主函数中,num一直都不会变,编译器avrstdio,外部中断。 调试中发现中断时可以进去的,然而中断出来以后,这个全局变量就被改变了,后来加了volitale就可以了
java线程同步之volatile
<em>volatile</em>的概念: <em>volatile</em>与synchronized关键字是多线程并发编程中非常重要的知识点,通常被用于<em>修饰</em>变量。相比于synchroinized来说,<em>volatile</em>要轻量很多,执行的成本会更低。原因是<em>volatile</em>不会引起线程上下文的切换和调度,但是它与synchronized的意义其实是有区别的。synchronized关键字主要体现的是互斥性,而<em>volatile</em>体现的便...
【多线程系列】Volatile总结之同步问题
Volatile总结之同步<em>问题</em> 在<em>java</em>线程并发处理中,有一个关键字<em>volatile</em>的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的,为了解决线程并发的<em>问题</em>,在语言内部引入了 同步块 和 <em>volatile</em> 关键字机制。     synchronized  同步块大家都比较熟悉,通过 synch
volatile失效,慎重使用volatile关键字
<em>volatile</em>关键字相信了解Java多线程的读者都很清楚它的作用。<em>volatile</em>关键字用于声明简单<em>类型变量</em>,如int、float、boolean等数据类型。如果这些简单数据类型声明为<em>volatile</em>,对它们的操作就会变成原子级别的。但这有一定的限制。例如,下面的例子中的n就不是原子级别的: package mythread;   public class JoinThread ext
volatile在,变量一定会安全吗?
在编程中,安全<em>问题</em>一直是我们关注的重点,能否确保程序在多线程的情况下实现安全,这应该一直是各位攻城狮们极其在意的。今天小编就和大家一起接着上篇博客继续聊一聊 <em>关于</em>原子性和可见性的<em>问题</em>! ✎  什么是原子性       大家都知道,原子是构成物质的最小单位,所以可以将原子性理解成为不可分性,比如数据库中的第一范式,强调的列的原子性,即列不能再进行分割。而原子性在多线程的环境下,可以理解为某一个变
volatile修饰符的理解和使用
1. 什么是<em>volatile</em><em>修饰</em>符? <em>volatile</em>关键字是一种类型<em>修饰</em>符,用它声明的<em>类型变量</em>表示可以被某些编译器未知的因素更改,比如:操作系统、硬件或者其他线程等。遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问。 2. 一个简单的例子 <em>volatile</em> 影响编译器编译的结果。<em>volatile</em>变量是随时可能发生变化的,与<em>volatile</em>变
Volatile变量的读写
Java并发编程:<em>volatile</em>关键字解析    <em>volatile</em>这个关键字可能很多朋友都听说过,或许也都用过。在Java 5之前,它是一个备受争议的关键字,因为在程序中使用它往往会导致出人意料的结果。在Java 5之后,<em>volatile</em>关键字才得以重获生机。   <em>volatile</em>关键字虽然从字面上理解起来比较简单,但是要用好不是一件容易的事情。由于<em>volatile</em>关键字是与Java的内存模
使用volatile对其他线程实时可见
使用<em>volatile</em>对其他线程实时可见 背景: 今天继续做白老师布置的作业,今天来设计一个小场景来演示用<em>volatile</em><em>修饰</em>的变量对其他线程的可见性。 设计场景: 设计两个线程,第一个线程往已经定义好的list里面不断添加元素。 第二个线程不断读取这个list,当发现size等于10的时候,就输出日志并终止循环。 我们看这个list在有<em>volatile</em><em>修饰</em>和没<em>volatile</em><em>修饰</em>的区别...
jvm住内存与工作内存,内存模型反映的java多线程问题volatile修饰变量
jvm住内存与工作内存,内存模型反映的<em>java</em>多线程<em>问题</em> 转载自: http://blog.csdn.net/sc313121000/article/details/40266531 不加<em>volatile</em>这个<em>修饰</em>变量 每个线程访问修改变量的过程是:先访问jvm主内存,把主内存变量拷贝到工作内存,修改工作内存的变量后,回写到jvm主内存中。 用<em>volatile</em><em>修饰</em>变量 每个线程不会拷贝jv
日常小结-在内部类中必须使用Atomic原子类替换volatile
最近在看《<em>java</em>并发编程实战》的时候,发现了一些缺乏的知识点,这里做一下整理。这里强力推荐下这本书。向匿名内部类传递的参数必须是final类型的在第七章取消与关闭的时候,看到了程序清单7-20的时候有个注解 之所以采用AtomicBoolean来代替<em>volatile</em>类型的boolean,是因为能从内部的Runnable中访问hasNewMail标志,因此它必须是final类型以免修改。 之前在
测试volatile变量的读写性能
<em>volatile</em>变量与非<em>volatile</em>变量的区别在于,<em>volatile</em>变量每次读都需要去主内存读取最新的值,每次写也需要写回到主内存;非<em>volatile</em>变量允许在缓存中读写以加快计算速度。
Java中的static和volatile变量的区别?
在<em>java</em>中声明一个静态变量,意味着只有一个副本,无论创建了多少个类的对象,即使没有创建对象,变量也可以访问,但是线程可能具有本地缓存的值。 当变量<em>volatile</em>而不是静态时,每个object都有一个变量,所以,表面看来,与正常变量没有区别,但是与静态完全不同。然而,即使使用object字段,线程也可能在本地缓存变量值。 这意味着如果两个线程同时更新同一个对象的变量,并且该变量未被声明为volat
java中final与volatile-线程安全问题
在线程安全<em>问题</em>中final主要体现在安全发布<em>问题</em>上,在这里先讲一下什么事安全发布,在《<em>java</em>并发编程实践》一书中有讲,不过看起来挺难懂的…. public class Holder { private int n; public Holder(int n) { this.n = n; } public void assertSanity() {
javavolatile和synchronize的区别和比较
<em>volatile</em>和synchronize的比较: 1.<em>volatile</em>是线程同步的轻量级实现,所以<em>volatile</em>的性能要比synchronize好;<em>volatile</em>只能用于<em>修饰</em>变量,synchronize可以用于<em>修饰</em>方法、代码
并发编程之volatile 关键字(一)
在<em>java</em>线程并发处理中,有一个关键字<em>volatile</em>的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的,为了解决线程并发的<em>问题</em>,在语言内部引入了 同步块 和 <em>volatile</em> 关键字机制。 作用: 1.禁止指令重排 2.保证从主内存加载到线程工作内存的值一直可以变为最新的(操作过程并非原子性操作) synchronize...
Volatile 数组可见性问题
查阅了很多网上的资料,都是认为<em>volatile</em>只是对于数组<em>引用</em>可见,而对于数组元素不可见。然而本人在进行测试后,发现对于一个加了<em>volatile</em>的数组,它的元素在多线程分别进行读写操作时依旧是可见的。使用JDK1.8 ,测试代码如下:   class Test extends Thread { private <em>volatile</em> boolean[] isRunning = new b...
const, volatile同时修饰一个变量
const, <em>volatile</em>同时<em>修饰</em>一个变量
JAVA多线程并发变量控制方法之volatile修饰工作原理
在JAVA中,每个线程都有一块属于自己的工作内存区,该内存区会保存一份从主内存拷贝过来的公共变量值。不加<em>volatile</em>修身的变量在每个线程中的值修改一般都是独立的。及如下图所示。
Java 并发:volatile 关键字解析
在Java并发编程中,要想使并发程序能够正确地执行必须要保证三条原则:原子性、可见性和有序性。只要有一条原则没有被保证,就有可能导致线程安全性<em>问题</em>。<em>volatile</em>关键字被用来保证可见性,即保证共享变量的内存可见性以解决缓存一致性<em>问题</em>,同时其还会禁止进行指令重排序。<em>volatile</em>关键字主要用于使其他线程及时感知共享变量的修改并保证使用变量最新值,例如,用于<em>修饰</em>状态标记量和Double-Check(双重检查)中。
AtomicInteger的并发处理,Volatile修饰的成员变量
AtomicInteger 通俗地解释: 对某个内存值拷贝一个副本,某个线程若读到该副本,并对其进行计算,输出结果,在写入内存时,再次取出内存值和该副本比较,若副本和内存值相同,则把新的值写入内存。 较为官方的解释: 通过CAS(AtomicInteger)实现,CAS简而言之就是。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修
volatile型变量自增操作的隐患
用FindBugs跑自己的项目,爆出两处An increment to a <em>volatile</em> field isn’t atomic。相应报错的代码如下:<em>volatile</em> int num = 0; num++;  FindBugs针对这种类型的错误给出了相应的解释 An increment to a <em>volatile</em> field isn’t atomic This code incremen
java基础之如何正确使用volatile
<em>volatile</em>关键字在<em>java</em>多线程中有着比较重要作用,<em>volatile</em>主要作用是可以保持变量在多线程中是实时可见的,是<em>java</em>中提供的最轻量的同步机制。可见性在Java的内存模型中所有的的变量(这里的变量是类全局变量,并不是局部变量,局部变量在方法内并没有线程安全的<em>问题</em>,因为变量随方法调用完成而销毁)都是存放在主内存中的,而每个线程有自己的工作内存,每次线程执行时,会从主内存获取变量的拷贝,对变
java线程之volatile关键字
<em>volatile</em>关键字 一、一旦一个共享变量(类的成员变量,类的静态变量)被<em>volatile</em><em>修饰</em>之后,那么就具备了两层语义; (1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这个新值对其他线程来说是立即可见的。 (2)禁止进行指令重排序 二、注意 题目:<em>关于</em><em>volatile</em>关键字,下列描述不正确的是? A、用<em>volatile</em><em>修饰</em>的变量,每次更新对
使用关键字volatile时出现非线程安全的原因。
变量在内存中工作的过程如下图所示。由上,我们可以得出以下结论。read和load阶段:从主存复制变量到当前线程工作内存;use和assign阶段:执行代码,改变共享变量值;store和write阶段:用工作内存数据刷新主存对应变量的值。       在多线程环境中,use和assign是多次出现的,但这一操作并不是原子性,也就是在read和load之后,如果主内存count变量发生修改之后,线程工...
Java中volatile如何保证long和double的原子性操作
原创转载请注明出处:http://agilestyle.iteye.com/blog/2359969   关键字<em>volatile</em>的主要作用是使变量在多个线程间可见,但无法保证原子性,对于多个线程访问同一个实例变量需要加锁进行同步。 package org.fool.<em>java</em>.concurrent.<em>volatile</em>test; import <em>java</em>.util.concurrent.E...
面试题7——一个指针可以是volatile吗?
可以。 因为指针和普通变量一样,有事也有变化程序的不可控性。常见例:子中断服务子程序修改一个指向一个buffer的指针时,必须用<em>volatile</em>来<em>修饰</em>指针。 指针是一种普通的变量,从访问上没有什么不同于其他变量的特性。其保存的数值是个整形数据,和整型变量不同的是,这个整型数据指向的是一段内存地址。 ...
java能创造volatile数组吗
<em>java</em>能创造<em>volatile</em>数组吗可以创造,但是由于<em>volatile</em>指向的是数组的地址,而不是数组的内容,这样多线程访问时候无法访问到最新的数组内容,达不到效果...
浅谈volatile关键字
             今天学习CurrentHashMap源码,发现CurrentHashMap源码中有的属性是用<em>volatile</em><em>修饰</em>的,别人说<em>volatile</em>可以保证读写的内容是最新的。看到这句话的时候还是满脑子的问号。特地去了解了一下<em>volatile</em>的特性,现在就将了解到的一些内容记录下来,后面有时间会更加深入学习一下。              1.<em>volatile</em>可以保证在多线程读取...
c#中多线程修饰volatile
<em>volatile</em>是C#中用于控制同步的关键字,其意义是针对程序中一些敏感数据,不允许多线程同时访问,保证数据在任何访问时刻,最多有一个线程访问,以保证数据的完整性,<em>volatile</em>是<em>修饰</em>变量的<em>修饰</em>符。 1、<em>volatile</em>的使用场景 多个线程同时访问一个变量,CLR为了效率,允许每个线程进行本地缓存,这就导致了变量的不一致性。<em>volatile</em>就是为了解决这个<em>问题</em>,volat
volatile对变量可见性和非原子性测试
1、<em>关于</em>valitile对变量的可见性测试 package com.delicacy.oatmeal.<em>java</em>.<em>volatile</em>test; /** * valitile dome * <em>volatile</em> 关键字保证了操作的可见性 * valitie 最好用于一写多读的情况下 * {@link VolatileDemo2} 测试<em>volatile</em>不能保证对变量的操作是原子性 * @au...
volatile类型修饰符的理解
1.<em>volatile</em>和const相同都属于类型<em>修饰</em>符,但是两者是对立的。<em>volatile</em>表示<em>修饰</em>的变量可能会被后台程序改变,这种改变是未知的。变量如果加了<em>volatile</em><em>修饰</em>,每次对变量进行读取操作时都是从内存中去加载变量的内容,而不是从寄存器中拷贝内容。举个栗子:void main(void){     int a,b;    int i=10;    a=i;    b=i;}//在这个a=i...
volatile在i++情况下失效
<em>volatile</em>关键字<em>修饰</em>的变量在执行自增、自减操作时无效!
const和volatile变量是否可以同时修饰一个变量
<em>问题</em>:const和<em>volatile</em>是否可以同时<em>修饰</em>一个变量?有什么含义? 答案:如果一个变量不会被本程序改变,通常可能给它加上const,但如果该变量可能被其他程序改变而本程序又在检测这个变量的值,就需要给它加上<em>volatile</em>,于是变量就同时有<em>volatile</em>和const了,这个时候i具有const和<em>volatile</em>的双重属性。i变量不可以在编译过程中被程序代码修改,同时编译器不得对i进行优化
java挑战高并发(5):volatile变量修饰符的使用与问题
在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的。而随着JVM的成熟和优化,现在在多线程环境下<em>volatile</em>关键字的使用变得非常重要。 在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值
volatile为什么要修饰中断里的变量
原文地址:http://blog.csdn.net/fengyunjh6/article/details/9055359 共有四种情况: 就下面这三种情况,还有利用for循环去延时的程序防止被优化(编译器认为for循环没用而优化掉),没有其它了,如果是这几种,那就干脆直接用<em>volatile</em><em>修饰</em>: 一个是防止变量在其它地方被改变,而cash里没有改变,所以要求每次都要读取内
volatile 可以保证可见性,但不能保证原子性。某种意义上是线程不安全的
在<em>java</em>线程并发处理中,有一个关键字<em>volatile</em>的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的,为了解决线程并发的<em>问题</em>,在语言内部引入了 同步块 和 <em>volatile</em> 关键字机制。   synchronized  同步块大家都比较熟悉,通过 synchronized 关键字来实现,所有加上synchronized
C语言 volatile 修饰 变量作用 总结
<em>volatile</em> 影响编译器编译的结果,指出,<em>volatile</em> 变量是随时可能发生变化的,与<em>volatile</em>变量有关的运算,不要进行编译优化,以免出错,(VC++ 在产生release版可执行码时会进行编译优化,加<em>volatile</em>关键字的变量有关的运算,将不进行编译优化。)。  例如:  <em>volatile</em> int i=10;  int j = i;  ...  int k = i; 
对于volatile型变量的特殊规则
关键字是Java虚拟机提供的最轻量级的同步机制 当一个变量定义为<em>volatile</em>之后,它具有两种特性: 保证此变量对所有线程的可见性:当一条线程修改了这个变量的值时,新值能立即同步到主内存中,因此其他线程可以立即得知该变量修改后的值。 在以下两种情况下能保证线程的安全性,其余情况我们仍要通过加锁来保证原子性: 运行结果并不依赖变量的当前值,或者能够确保只有单一的线程修改变量的值 变量不需要...
并发(一):java并发概念以及Volatile可见性,重排序
参考:<em>java</em>并发编程的艺术-方腾飞 1.线程通信与线程同步: 通信:指线程之间以何种机制来交换信息。 a.共享内存模式即:线程之间共享程序的公共状态,通过读写内存中的公共状态来进行间接通信。 b.消息传递模式:线程之间没有公共状态,线程之间必须通过发送消息来直接进行通信。 同步:程序中用于控制不同线程间操作发生相对顺序的机制。 a.共享内存模式中:某个方法或某段代码在线程之间
Volatile关键字与线程安全
<em>volatile</em>和多线程资源访问控制分别介绍 一、<em>volatile</em>关键字: <em>volatile</em>关键字,它的语义有二: 1. <em>volatile</em><em>修饰</em>的变量对于其他线程具有立即可见性,即该值发生变化时,其他线程可以立马知道。而普通变量,值发生变化后,需要经过store、write将变量从当前线程的工作副本写入主内存,其他线程再从主内存通过read、load将变量同步到自己的工作内存,由于时
volatile非线程安全解析
Java内存模型 <em>java</em>使用的是共享变量模型,如下图所示   线程1要读取线程2修改后的值必须要线程2写回到内存,线程1再读取。 Jvm又是如何读取主存变量到线程中的呢?   内存间的相互操作 lock 将对象变成线程独占的状态 unlock 将线程独占状态的对象的锁释放出来 read 从主内存读数据 load 将从主内存读取的数据写入工作内存 use 工作内存使用对象 ...
C#多线程同步(九)【volatile
每个人都是自己的上帝。如果你自己都放弃自己了,还有谁会救你?每个人都在忙,有的忙着生,有的忙着死。忙着追名逐利的你,忙着柴米油盐的你,停下来想一秒:你的大脑,是不是已经被体制化了?你的上帝在哪里?# class Test { //<em>volatile</em>多用于多线程的环境,当一个变量定义为<em>volatile</em>时,读取这个变量的值时候每次都是从momery里面读取而不是从cache读。
JAVA多线程-对象及变量的并发访问(二)volatile关键字
三、Volatile关键字     关键字<em>volatile</em>的主要作用是使变量在多个线程间可见。 3.1 关键字<em>volatile</em>与死循环 测试案例: 我想通过改变flag的值,从而停止对service的test()方法,进行停止。package org.jksoft.thread.Volatile; public class Test1 { public static void main(S
volatile使用场景
一.前言1.编译器优化介绍:由于内存访问速度远不及CPU处理速度,为提高机器整体性能,在硬件上引入硬件高速缓存Cache,加速对内存的访问。另外在现代CPU中指令的执行并不一定严格按照顺序执行,没有相关性的指令可以乱序执行,以充分利用CPU的指令流水线,提高执行速度。以上是硬件级别的优化。再看软件一级的优化:一种是在编写代码时由程序员优化,另一种是由编译器进行优化。编译器优化常用的方法有:将内存变...
Android并发编程之图文解析volatile关键字
相信很多人对于<em>volatile</em>关键字既熟悉又陌生,熟悉是对这个名字很熟悉,陌生是对他的原理和用法很陌生,最近几天通过查阅大量资料和书,终于对<em>volatile</em>有了一定的理解,写此博客一来做了记录,二来使大家减少学习成本<em>volatile</em>为什么不能保证原子性?现在我们的手机都是多核的,也就是说同时有好几颗CPU在工作,每颗CPU都有自己的Cache高速缓存,因为CPU的速度特别快,而内存的读取操作相对于C
const和volatile同时修饰同一个变量
主要要搞清楚 编译期 和 运行期的关系。 编译期就是 C 编译器将 源代码转化为 汇编再到机器代码 的过程。 运行期就是 实际的机器代码在CPU执行 的过程。很多书上说的东西,其实都只是指编译期进行的事情。const 和 <em>volatile</em> 也一样,所谓的 const ,只是告诉编译器要保证在 C的“源代码”里面,没有对该变量进行修改的地方,就是该变量不能而出现在赋值符号左边。实际运行的时候则不是
Java基础 第二篇 接着讲synchronized修饰符与volatile修饰
synchronized(同步 英译):一次只能有一个线程访问; <em>volatile</em>(易变的不稳定的 英译):被<em>修饰</em>的变量每次变换时或者每次被线程访问时都会强制要求其回到!共享!内存中修改值,保证所有线程同时能知道这个值的变化。再往(多线程线程模型 : 主存,线程栈)每当线程处理完数据后都会把值从主存load到方法栈,完成后再save回去,(<em>volatile</em>关键词的作用:每次针对该变量的操作都激发...
Java多线程复习与巩固(九)--volatile关键字与CAS操作
前一篇文章中提到原子操作,也许大家和我一样很好奇为什么AtomicInteger.increment方法能保证原子性,而简单的++运算却不能保证原子性。这篇文章我们就从AtomicInteger类下手分析源码,来了解一下原子操作的实现原理,但是分析源码之前需要来一段小小的前奏。 CPU内存架构 现代计算机都是多处理机CPU,每个核心(Core)都有一套寄存器,CPU访问寄存器的速度是最快的...
Java基础面试总结(四、深入理解volatile关键字)
被<em>volatile</em><em>修饰</em>的变量,可以保证不同的线程都能多能取得最新状态值;<em>volatile</em>保证了可见性,避免在线程在缓存中取旧值;1. <em>volatile</em> 保证可见性一旦一个共享变量(类的成员变量、类的静态成员变量)被<em>volatile</em><em>修饰</em>之后,那么就具备了两层语义:1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。2)禁止进行指令重排序。2...
变量可见性和volatile, this逃逸, 不可变对象, 以及安全公开
线程安全包含2个方面: 原子性和可见性, <em>java</em>的同步机制都是围绕这2个方面来确保线程安全的. 可见性 理解可见性首先要清楚为什么多线程环境下会有可见性<em>问题</em>. 现代CPU一般都使用读写速度很快的高速缓存来作为内存和CPU之间的缓冲, 高速缓存的引入可以有效的解决CPU和内存的速度矛盾, 但是也带来了新的<em>问题</em>: 缓存一致性. 在多CPU的系统中, 每个处理器都有自己的高速缓存, 而高速...
正确使用Volatile关键字
Java 语言中的 <em>volatile</em> 变量可以被看作是一种 “程度较轻的 synchronized”;与 synchronized 块相比,<em>volatile</em> 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是synchronized 的一部分。本文介绍了几种有效使用 <em>volatile</em> 变量的模式,并强调了几种不适合使用 <em>volatile</em> 变量的情形。 锁提供了两种主
Java多线程:慎重使用volatile关键字
<em>volatile</em>关键字相信了解Java多线程的读者都很清楚它的作用。<em>volatile</em>关键字用于声明简单<em>类型变量</em>,如int、float、boolean等数据类型。如果这些简单数据类型声明为<em>volatile</em>,对它们的操作就会变成原子级别的。但这有一定的限制。例如,下面的例子中的n就不是原子级别的: package mythread;   public class JoinThread extends
Java的long、double类型的原子性读取问题
Java的longdouble类型的原子性读取<em>问题</em> 检验Java的long、double类型的原子性读取<em>问题</em> In programming, an atomic action is one that effectively happens all at once. An atomic action cannot stop in the middle: it either happens comp
volatile 修饰的属性,在多线程修改下,也是线程不安全的
<em>volatile</em> <em>修饰</em>的对象,在多线程修改下,也是线程不安全的   package ThreadTest; public class ThreadTest3 { public static void main(String args[]){ MyThread mt = new MyThread() ; // 定义线程对象 Th...
双重校验锁 为啥要用volatile修饰
public class Single { private static <em>volatile</em> Single single; public static Single getSingle(){ if (single==null){ synchronized (Single.class){ if (single==...
深入理解volatile的内存语义,并通过volatile写一个线程安全的单例
前言: 对缓存一致性协议以及内存屏障和happens-before原则不太了解的小伙伴建议先百度google维基一下或移步的我的另一篇博客《浅谈缓存一致性原则和Java内存模型(JMM)》之后再看这篇博客更好理解哦 在研究Java并发包之前一直以为<em>volatile</em>关键字只是一个打辅助的,之后发现J.U.C包的底层就是依靠<em>volatile</em>关键字和CAS实现的。那我们现在就来看一看<em>volatile</em>...
长话短说-Java中的volatile(面试常见)
<em>volatile</em>,是Java提供的一种轻量级的同步机制,在并发编程中可以发挥一定作用,相对于sync的开销来讲要小的多;<em>volatile</em>具备两个特性:特性1.保证共享变量对所有线程的可见性;      可见性:指当一个线程修改了共享变量的值,新值对于其他线程来说都是立即有感知的。      补充:Java内存模型(JMM) jmm决定了一个线程对共享变量的写入何时对其他线程可见,jmm定义了线程和...
Java并发编程(三)volatile
有时仅仅为了读写一个或者两个实例域就使用同步的话,显得开销过大,<em>volatile</em>关键字为实例域的同步访问提供了免锁的机制。如果声明一个域为<em>volatile</em>,那么编译器和虚拟机就知道该域是可能被另一个线程并发更新的。再讲到<em>volatile</em>关键字之前我们需要了解一下内存模型的相关概念以及并发编程中的三个特性:原子性,可见性和有序性。
嵌入式编程(以STM32为例)中的volatile,const意义及应用场景
__I、 __O 、__IO是什么意思? 这是ST库里面的宏定义,定义如下: #define     __I       <em>volatile</em> const        /*! #define     __O       <em>volatile</em>                  /*! #define     __IO      <em>volatile</em>                  /*!
volatile无法保证i++原子性的解决方案
一、阻塞算法与非阻塞算法1、阻塞算法以常见的同步实现方式synchronized为例,同一时间段,同一个锁,只能有一个线程获得,其他未获取到的线程阻塞,直到拥有锁的线程释放锁。下图演示了一个阻塞算法保证一个共享数据结构的行为:2、非阻塞算法线程A请求某种操作,如果系统无法响应;则通知A线程,A可先去执行其他操作;下图演示了一个非阻塞算法保证一个共享数据结构的行为:二、Volatile 变量存在的<em>问题</em>
volatile作用、优缺点、原理
参数书籍:《Java性能优化权威指南》、《Java并发编程实战》作用:    <em>volatile</em>字段值在 所有的线程 和 CPU缓存中必须保持同步。(参考Java内存模型)    简单讲,你读取的<em>volatile</em>字段必然是上次写入的,而无关乎那个线程写入的。线程安全:    线程安全考虑 可见性、原子性。<em>volatile</em>字段本身保证了可见性,但我们编程时 仍要保证原子性,如下伪码。if(volati...
java-Transient关键字、Volatile关键字介绍和序列化、反序列化机制、单例类序列化
- Transient关键字 Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想 用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。 transient是Java语言的关键字,用来表示一个域不是该对象串行化的一部分
volatile关键字线程安全问题
在印象中,<em>volatile</em>修改的变量是线程安全的,我一直这么认为,殊不知还有条件的: 1. 运算结果并不依赖变量的当前值,或者能够确保只有单一线程修改变量的值. 2. 变量不需要与其他的状态变理共同参与不变约束。 [code=&quot;<em>java</em>&quot;] public class VolatileTest{ public static <em>volatile</em> int race = 0; ...
C语言类型修饰符 在这个上边吃大亏了啊 volatile
今天调试程序的时候出了一个非常奇怪的bug,令我百思不得其解,最后还是我的项目经理给我指出<em>问题</em>所在,原来是<em>volatile</em> 在搞鬼 所以痛下决心弄明白这些陷阱。 编译器会对程序进行优化,在某些情况下,会把变量内存中的值取到寄存器中,内存的值变了,但是寄存器的值可能没有变,这是
Java并发编程番外篇(三)volatile变量、happens-before与内存一致性错误
Java并发编程番外篇(三)<em>volatile</em>变量、happens-before与内存一致性错误<em>volatile</em>变量<em>volatile</em>是Java的关键词,我们可以用它来<em>修饰</em>变量或者方法。为什么要使用<em>volatile</em><em>volatile</em>的典型用法是,当多个线程共享变量,且我们要避免由于内存缓冲变量导致的内存一致性(Memory Consistency Errors)错误时。考虑以下的生产者消费者例子,在一个时
【c/c++】C++中volatile类型修饰符的深入理解
为什么用<em>volatile</em>? C/C++ 中的 <em>volatile</em> 关键字和 const 对应,用来<em>修饰</em>变量,通常用于建立语言级别的 memory barrier。这是 BS 在 “The C++ Programming Language” 对 <em>volatile</em> <em>修饰</em>词的说明: A <em>volatile</em> specifier is a hint to a compiler that an object ...
__I、 __O 、__IO volatile是什么?怎么用?(作者写的太棒了,给赞)
__I、 __O 、__IO是什么意思?  这是ST库里面的宏定义,定义如下: #define __I <em>volatile</em> const /*! #define __O <em>volatile</em> /*! #define __IO <em>volatile</em> /*! 显然,这三个宏定义都是用来替换成 <em>volatile</em> 和 const 的,所以我们先要了解 这两个关键字的作用:  volatil
单例模式singleton为什么要加volatile
或者许多的朋友在使用单例模式中会学到双重检查加锁(double-checked locking)的应用。public class Singleton { private <em>volatile</em> static Singleton uniqueInstance; private Singleton(){} public static Singleton getInstance(){
JAVA中final、static、volatile在字节码文件中的表现
  说到这几个关键字,大部分猿都能娓娓道来,说出很多它们的用法和定义 final<em>修饰</em>的字段不可修改、方法不可重写、类不可继承,JVM对final有优化 static<em>修饰</em>的字段所有对象共用、static{}内的代码在类加载时执行、JVM对static有优化 <em>volatile</em><em>修饰</em>的字段所有线程看到的值一致 问:JVM对final和static有什么优化? 我:??? 问:为什么<em>volatile</em>...
jvm volatile 实现并发 解决副本缓存变量在工作内存中获取最后的值
 在Java线程并发处理中,有一个关键字<em>volatile</em>的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。Java语言是支持多线程的,为了解决线程并发的<em>问题</em>,在语言内部引入了 同步块(synchronized) 和 <em>volatile</em> 关键字机制。 synchronized(不做过多解释)同步块大家都比较熟悉,通过 synchronized 关键字来实现,所有加...
关于volatile关键字无法保证原子性”的一些理解
Volatile关键字的粗浅理解在学习并发编程的时候了解到,<em>volatile</em>关键字有两个作用:1. 并发环境可见性:<em>volatile</em><em>修饰</em>后的变量能够保证该变量在线程间的可见性,线程进行数据的读写操作时将绕开工作内存(CPU缓存)而直接跟主内存进行数据交互,即线程进行<em>读操作</em>时直接从主内存中读取,写操作时直接将修改后端变量刷新到主内存中,这样就能保证其他线程访问到的数据是最新数据2. 并发环境有序性:...
const 和 volatile 成员函数、mutable 数据成员
const 和 <em>volatile</em> 成员函数、mutable 数据成员        为尊重类对象的常量性,编译器必须区分不安全与安全的成员函数(即区分试图修改类对象与不试图修改类对象的函数)。       const成员函数:       类的设计者通过把成员函数声明为 const ,以表明它们不修改类对象。只有被声明为 const 的成员函数才能被一个 const 类
还在使用 Synchronized同步?试试 Volatile 吧,让你的代码更高效
Synchronized 运用synchronized关键字来实现同步块,大家都比较熟悉。为了避免多线程 同一时间 访问 同一方法或代码块时,方法产生和预期不同的结果,我们一般在这一方法或者代码块前使用synchronized关键字来<em>修饰</em>,从而保证方法或者代码块同一时刻只能有一个线程可以使用。 synchronized 三大特性:地址 地址 可见性:synchronized能够保证同步块
文章热词 设计制作学习 颜色模型 像质量评价标准 机器学习教程 Objective-C培训
相关热词 ios获取idfa server的安全控制模型是什么 sql ios 动态修改约束 android title搜索 学习java的问题与收获 关于java类机器学习
我们是很有底线的