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

Bbs1
本版专家分:0
结帖率 33.33%
Bbs5
本版专家分:2039
Blank
黄花 2017年3月 Java大版内专家分月排行榜第二
Bbs1
本版专家分:0
Bbs1
本版专家分:0
Bbs4
本版专家分:1408
Bbs1
本版专家分:0
C语言 静态变量static的用法
static有两个作用 第一个作用: <em>修饰</em>变量,变量又分为局部和全局变量,但他们都存在内存的静态区               静态全局变量,作用于仅限于变量被定义的文件。其他文件即使用extern声明也没法使用,准确说就是作用域是从定义处开始,到文件结束,                        在定义处之前的那些代码不能使用它。               静态局
C语言再学习 -- 关键字volatile
占楼
【Java并发编程】之五:volatile变量修饰符—意料之外的问题(含代码)
在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的。而随着JVM的成熟和优化,现在在多线程环境下<em>volatile</em>关键字的使用变得非常重要。 在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值的拷贝,造成数据的不一致。 要解决这个<em>问题</em>,就需要把变量声明为<em>volatile</em>(不稳定的),这就指示JVM,这个变量是不稳
volatile的特性
当我们声明共享变量为<em>volatile</em>后,对这个变量的读/写将会很特别。理解<em>volatile</em>特性的一个好方法是:把对<em>volatile</em>变量的单个读/写,看成是使用同一个监视器锁对这些单个读/写操作做了同步。下面我们通过具体的示例来说明,请看下面的示例代码: class VolatileFeaturesExample { <em>volatile</em> long vl = 0L; //使用<em>volatile</em>
彻底理解java语言的线程安全volatile用法
Java 语言中的 <em>volatile</em> 变量可以被看作是一种 “程度较轻的 synchronized”;与 synchronized 块相比,<em>volatile</em> 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 <em>volatile</em> 变量的模式,并强调了几种不适合使用 <em>volatile</em> 变量的情形。 锁提供了两种主要特性
【并发】volatile是否能保证数组中元素的可见性?
  <em>问题</em>   一个线程向<em>volatile</em>的数组中设置值,而另一个线程向<em>volatile</em>的数组中读取。 比如seg.setValue(2),随后另一个线程调用seg.getValue(2),前一个线程设置的值对读取的线程是可见的吗? 我看书上说<em>volatile</em>的数组只针对数组的<em>引用</em>具有<em>volatile</em>的语义,而不是它的元素。   对一个共享变量使用Volatile关键字保证了线程间对该数...
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
java中的volatile关键字的功能详解
Cookie的应用场景: 1,记录用户的登陆状态,提示用户是否记住密码; 2,购物车购物功能; 我们知道,在web开发过程中,我们都要和cookie打交道,有时候离开了cookie还真玩不转。cookie最典型的应用莫过于登陆提示,最近在做一个小项目,正好要用到cookie的知识,在这里顺便做一下总结。
对Volatile变量的理解和总结
之前因为对Volatile变量的理解不够深刻,只是知道它可以轻量级的锁,但是在真正编写多线程的程序时,除用它来做为线程结束的标志外,并不敢过多的使用。但是在看Current包中的大部分源码时发现,作者居然使用Volatile变量加CAS操作实现了很多只有通过加锁才能实现的功能,叹为观止。然后就在前面了解了JMM的基础上,又去详细的了解了一下Volatile变量的使用。 <em>volatile</em>变量的读写对所
c语言中头文件的建立与使用-函数、全局变量、全局数组
一些初学C语言的人,不知道头文件(*.h文件)原来还可以自己写的。只知道调用系统库函数时,要使用#i nclude语句将某些头文件包含进去。其实,头文件跟.C文件一样,是可以自己写的。头文件是一种文本文件,使用文本编辑器将代码编写好之后,以扩展名.h保存就行了。头文件中一般放一些重复使用的代码,例如函数声明,变量声明,常数定义,宏的定义等等。当使用#i nclude语句将头文件<em>引用</em>时,相当于将头文件中所有内容,复制到#i nclude处。为了避免因为重复<em>引用</em>而导致的编译错误,头文件常具有<br
java中Volatile修饰符的含义
在<em>java</em>语言中:为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值进行对比。         <em>volatile</em>关键字的作用就是提示vm:对于这个成员变量不能保存它的私有拷贝,而应直接与共享变量进行交互。         被<em>volatile</em><em>修饰</em>符<em>修饰</em>的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成
Java并发编程-正确理解volatile关键字的两层语义
<em>关于</em>关键字<em>volatile</em>可以说是Java虚拟机提供的轻量级的同步机制,但是它并不容易完全被正常、完整地理解,以至于许多程序员都不习惯去使用它,遇到需要处理多线程数据竞争<em>问题</em>的时候一律使用Synchronized来进行同步。了解<em>volatile</em>变量的语义对了解多线程操作的其他特性很有意义。本篇文章将结束<em>volatile</em>关键字的两类语义:可见性和禁止指令重拍序。 1.volatil
Java关键字volatile修饰变量
<em>volatile</em>关键字的作用是告诉编译器,凡是被该关键字申明的变量都是易变的、不稳定的,所以不要试图对该变量使用缓存等优化机制,而应当每次都从他的内存地址中去读取值,但<em>volatile</em>并不是每次更改完就要立刻将他写回内存,<em>volatile</em>只提供了内存的可见性,并不提供原子性(与锁机制的区别:锁机制即提供了内存的可见性又提供了原子性)。   使用<em>volatile</em>标记的变量在读取或写入时不需要使用锁,
Java中有关volatile的几个小面试题
码农小二哥 2017-05-10 16:01 1)Java 中能创建 <em>volatile</em> 数组吗? 能,Java 中可以创建 <em>volatile</em> 类型数组,不过只是一个指向数组的<em>引用</em>,而不是整个数组。我的意思是,如果改变<em>引用</em>指向的数组,将会受到 <em>volatile</em> 的保护,但是如果多个线程同时改变数组的元素,<em>volatile</em> 标示符就不能起到之前的保护作用了。 2)<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>关键字有两个作用:1. 并发环境可见性:<em>volatile</em><em>修饰</em>后的变量能够保证该变量在线程间的可见性,线程进行数据的读写操作时将绕开工作内存(CPU缓存)而直接跟主内存进行数据交互,即线程进行<em>读操作</em>时直接从主内存中读取,写操作时直接将修改后端变量刷新到主内存中,这样就能保证其他线程访问到的数据是最新数据2. 并发环境有序性:...
volatile变量类型的详细说明
关键字<em>volatile</em>是<em>java</em>虚拟机提供的最轻量级的同步机制
关于volatile对变量自增不保证原子性的原因所产生的疑问。
在多线程情况下,有i变量: <em>volatile</em> int i = 0; 这种情况下,如果多线程对i进行自增操作:i++,结果可能会与预期值不同,这是什么原因呢? 先来看看大多人对这一错误的解释: 是因为<em>volatile</em>不能保证原子性,而i++其实有三步操作,读,修改,写,并不是原子操作,所以<em>volatile</em>当然不能保证结果的准确性,解释完毕! 其实博主我觉得这种解释相当的流氓 让我想起
测试volatile变量的读写性能
<em>volatile</em>变量与非<em>volatile</em>变量的区别在于,<em>volatile</em>变量每次读都需要去主内存读取最新的值,每次写也需要写回到主内存;非<em>volatile</em>变量允许在缓存中读写以加快计算速度。
java中的Volatile关键字(成员变量修饰符)
Volatile<em>修饰</em>的成员变量在每次被线程访问时,都强迫从共享内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到共享内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。 Java语言规范中指出:为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。 这样当多个线程同时与某个对象交
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>的区别...
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() {
日常小结-在内部类中必须使用Atomic原子类替换volatile
最近在看《<em>java</em>并发编程实战》的时候,发现了一些缺乏的知识点,这里做一下整理。这里强力推荐下这本书。向匿名内部类传递的参数必须是final类型的在第七章取消与关闭的时候,看到了程序清单7-20的时候有个注解 之所以采用AtomicBoolean来代替<em>volatile</em>类型的boolean,是因为能从内部的Runnable中访问hasNewMail标志,因此它必须是final类型以免修改。 之前在
Java 并发:volatile 关键字解析
在Java并发编程中,要想使并发程序能够正确地执行必须要保证三条原则:原子性、可见性和有序性。只要有一条原则没有被保证,就有可能导致线程安全性<em>问题</em>。<em>volatile</em>关键字被用来保证可见性,即保证共享变量的内存可见性以解决缓存一致性<em>问题</em>,同时其还会禁止进行指令重排序。<em>volatile</em>关键字主要用于使其他线程及时感知共享变量的修改并保证使用变量最新值,例如,用于<em>修饰</em>状态标记量和Double-Check(双重检查)中。
volatile和重排序得一些小疑问
http://yeziwang.iteye.com/blog/1042492  好吧,这里我只想说说<em>volatile</em>在JMM中的语义。     当我们在使用<em>volatile</em>的时候,实际上它表达了下面那么些意思。      1. 可见性。       这个是大多数人都知道的一个特质, JAVA的线程有自己的工作内存区,与主存区不同,当我们对变量使用了<em>volatile</em>后,那么不管对这个...
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...
Java中volatile关键字的最全总结
一、简介<em>volatile</em>是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制:同步块(或方法)和 <em>volatile</em> 变量,相比于synchronized(synchronized通常称为重量级锁),<em>volatile</em>更轻量级,因为它不会引起线程上下文的切换和调度。但是<em>volatile</em> 变量的同步性较差(有时它更简单并且开销更低),而且其使用也更容易出错。二、并发编程的3个基本概...
关于全局变量被修改以及volatile的用法
..... unsigned char num=0; ..... INTERRUPT() { .... num++; .... } void main() { out(num); } 很不幸的事情是在主函数中,num一直都不会变,编译器avrstdio,外部中断。 调试中发现中断时可以进去的,然而中断出来以后,这个全局变量就被改变了,后来加了volitale就可以了
javavolatile和synchronize的区别和比较
<em>volatile</em>和synchronize的比较: 1.<em>volatile</em>是线程同步的轻量级实现,所以<em>volatile</em>的性能要比synchronize好;<em>volatile</em>只能用于<em>修饰</em>变量,synchronize可以用于<em>修饰</em>方法、代码
const, volatile同时修饰一个变量
const, <em>volatile</em>同时<em>修饰</em>一个变量
volatile变量与普通变量的区别
Java团长 2017-10-06 22:46 我们通常会用<em>volatile</em>实现一些需要线程安全的代码(也有很多人不敢用,因为不了解),但事实上<em>volatile</em>本身并不是线程安全的,相对于synchoronized,它有更多的使用局限性,只能限制在某些特定的场景。本篇文章的目的就是让大家对 <em>volatile</em> 在本质上有个把握,为了达到这个目的,我们会从<em>java</em> 的内存模型及变量操作的内存
java如何正确使用volatile
<em>volatile</em>关键字在<em>java</em>多线程中有着比较重要作用,<em>volatile</em>主要作用是可以保持变量在多线程中是实时可见的,是<em>java</em>中提供的最轻量的同步机制。可见性在Java的内存模型中所有的的变量(这里的变量是类全局变量,并不是局部变量,局部变量在方法内并没有线程安全的<em>问题</em>,因为变量随方法调用完成而销毁)都是存放在主内存中的,而每个线程有自己的工作内存,每次线程执行时,会从主内存获取变量的拷贝,对变
并发编程之volatile 关键字(一)
在<em>java</em>线程并发处理中,有一个关键字<em>volatile</em>的使用目前存在很大的混淆,以为使用这个关键字,在进行多线程并发处理的时候就可以万事大吉。 Java语言是支持多线程的,为了解决线程并发的<em>问题</em>,在语言内部引入了 同步块 和 <em>volatile</em> 关键字机制。 作用: 1.禁止指令重排 2.保证从主内存加载到线程工作内存的值一直可以变为最新的(操作过程并非原子性操作) synchronize...
Java并发编程(三)volatile
有时仅仅为了读写一个或者两个实例域就使用同步的话,显得开销过大,<em>volatile</em>关键字为实例域的同步访问提供了免锁的机制。如果声明一个域为<em>volatile</em>,那么编译器和虚拟机就知道该域是可能被另一个线程并发更新的。再讲到<em>volatile</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进行优化
volatile在i++情况下失效
<em>volatile</em>关键字<em>修饰</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)错误时。考虑以下的生产者消费者例子,在一个时
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
c#中多线程修饰volatile
<em>volatile</em>是C#中用于控制同步的关键字,其意义是针对程序中一些敏感数据,不允许多线程同时访问,保证数据在任何访问时刻,最多有一个线程访问,以保证数据的完整性,<em>volatile</em>是<em>修饰</em>变量的<em>修饰</em>符。 1、<em>volatile</em>的使用场景 多个线程同时访问一个变量,CLR为了效率,允许每个线程进行本地缓存,这就导致了变量的不一致性。<em>volatile</em>就是为了解决这个<em>问题</em>,volat
Java中的static和volatile变量的区别?
在<em>java</em>中声明一个静态变量,意味着只有一个副本,无论创建了多少个类的对象,即使没有创建对象,变量也可以访问,但是线程可能具有本地缓存的值。 当变量<em>volatile</em>而不是静态时,每个object都有一个变量,所以,表面看来,与正常变量没有区别,但是与静态完全不同。然而,即使使用object字段,线程也可能在本地缓存变量值。 这意味着如果两个线程同时更新同一个对象的变量,并且该变量未被声明为volat
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; 
Java基础面试总结(四、深入理解volatile关键字)
被<em>volatile</em><em>修饰</em>的变量,可以保证不同的线程都能多能取得最新状态值;<em>volatile</em>保证了可见性,避免在线程在缓存中取旧值;1. <em>volatile</em> 保证可见性一旦一个共享变量(类的成员变量、类的静态成员变量)被<em>volatile</em><em>修饰</em>之后,那么就具备了两层语义:1)保证了不同线程对这个变量进行操作时的可见性,即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。2)禁止进行指令重排序。2...
const和volatile同时修饰同一个变量
主要要搞清楚 编译期 和 运行期的关系。 编译期就是 C 编译器将 源代码转化为 汇编再到机器代码 的过程。 运行期就是 实际的机器代码在CPU执行 的过程。很多书上说的东西,其实都只是指编译期进行的事情。const 和 <em>volatile</em> 也一样,所谓的 const ,只是告诉编译器要保证在 C的“源代码”里面,没有对该变量进行修改的地方,就是该变量不能而出现在赋值符号左边。实际运行的时候则不是
JAVA多线程并发变量控制方法之volatile修饰工作原理
在JAVA中,每个线程都有一块属于自己的工作内存区,该内存区会保存一份从主内存拷贝过来的公共变量值。不加<em>volatile</em>修身的变量在每个线程中的值修改一般都是独立的。及如下图所示。
Java关键字之volatile(可见性,有序性)
一. <em>volatile</em>关键字是什么? 当一个变量定义为<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>的特殊规则 关键字<em>volatile</em>可以说是Java虚拟机提供的最轻量级的同步机制,但是它并不容易完全被正确、 完整地理解,以至于许多程序员都习惯不去使用它,遇到需要处理多线程数据竞争<em>问题</em>的时候一律使用synchronized来进行同步。 当一个变量定义为<em>volatile</em>之后,它将具备两种特性:一是可见性,二是会禁...
Java中 volatile关键字怎么禁止重排序
使用<em>volatile</em>关键字<em>修饰</em>共享变量可以禁止重排序。若用<em>volatile</em><em>修饰</em>共享变量,在编译时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序   <em>volatile</em>禁止指令重排序的一些规则:   1.当第二个操作是voaltile写时,无论第一个操作是什么,都不能进行重排序   2.当地一个操作是<em>volatile</em>读时,不管第二个操作是什么,都不能进行重排序   3.当第一个操作是
浅谈volatile关键字
             今天学习CurrentHashMap源码,发现CurrentHashMap源码中有的属性是用<em>volatile</em><em>修饰</em>的,别人说<em>volatile</em>可以保证读写的内容是最新的。看到这句话的时候还是满脑子的问号。特地去了解了一下<em>volatile</em>的特性,现在就将了解到的一些内容记录下来,后面有时间会更加深入学习一下。              1.<em>volatile</em>可以保证在多线程读取...
volatile在,变量一定会安全吗?
在编程中,安全<em>问题</em>一直是我们关注的重点,能否确保程序在多线程的情况下实现安全,这应该一直是各位攻城狮们极其在意的。今天小编就和大家一起接着上篇博客继续聊一聊 <em>关于</em>原子性和可见性的<em>问题</em>! ✎  什么是原子性       大家都知道,原子是构成物质的最小单位,所以可以将原子性理解成为不可分性,比如数据库中的第一范式,强调的列的原子性,即列不能再进行分割。而原子性在多线程的环境下,可以理解为某一个变
多线程---volatile关键字
在多线程中,<em>volatile</em>关键字是很重要的一个知识点,在多线程共享资源的时候,每个线程数据对外都是不可见的,这就容易出现”脏读”现象,其实就是线程私有堆栈中的数据和公共堆栈中的数据不同步造成的.解决这样的<em>问题</em>,就要使用<em>volatile</em>关键字了。 内存结构 有这个结构图,就能很清晰的知道为毛会造成数据的不同步了。每个线程都会有各自的线程栈,执行运算的时候,是从公共堆栈读取数据到线程堆栈中,线程
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
Android并发编程之图文解析volatile关键字
相信很多人对于<em>volatile</em>关键字既熟悉又陌生,熟悉是对这个名字很熟悉,陌生是对他的原理和用法很陌生,最近几天通过查阅大量资料和书,终于对<em>volatile</em>有了一定的理解,写此博客一来做了记录,二来使大家减少学习成本<em>volatile</em>为什么不能保证原子性?现在我们的手机都是多核的,也就是说同时有好几颗CPU在工作,每颗CPU都有自己的Cache高速缓存,因为CPU的速度特别快,而内存的读取操作相对于C
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...
长话短说-Java中的volatile(面试常见)
<em>volatile</em>,是Java提供的一种轻量级的同步机制,在并发编程中可以发挥一定作用,相对于sync的开销来讲要小的多;<em>volatile</em>具备两个特性:特性1.保证共享变量对所有线程的可见性;      可见性:指当一个线程修改了共享变量的值,新值对于其他线程来说都是立即有感知的。      补充:Java内存模型(JMM) jmm决定了一个线程对共享变量的写入何时对其他线程可见,jmm定义了线程和...
对于volatile型变量的特殊规则
关键字是Java虚拟机提供的最轻量级的同步机制 当一个变量定义为<em>volatile</em>之后,它具有两种特性: 保证此变量对所有线程的可见性:当一条线程修改了这个变量的值时,新值能立即同步到主内存中,因此其他线程可以立即得知该变量修改后的值。 在以下两种情况下能保证线程的安全性,其余情况我们仍要通过加锁来保证原子性: 运行结果并不依赖变量的当前值,或者能够确保只有单一的线程修改变量的值 变量不需要...
java-Transient关键字、Volatile关键字介绍和序列化、反序列化机制、单例类序列化
- Transient关键字 Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想 用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。 transient是Java语言的关键字,用来表示一个域不是该对象串行化的一部分
java挑战高并发(5):volatile变量修饰符的使用与问题
在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的。而随着JVM的成熟和优化,现在在多线程环境下<em>volatile</em>关键字的使用变得非常重要。 在当前的Java内存模型下,线程可以把变量保存在本地内存(比如机器的寄存器)中,而不是直接在主存中进行读写。这就可能造成一个线程在主存中修改了一个变量的值,而另外一个线程还继续使用它在寄存器中的变量值
如何正确使用volatile变量
Java 语言中的 <em>volatile</em> 变量可以被看作是一种 “程度较轻的 synchronized”;与 synchronized 块相比,<em>volatile</em> 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 <em>volatile</em> 变量的模式,并强调了几种不适合使用 <em>volatile</em> 变量的情形。 锁提供了两种主要特性:互斥(
举例解析Java中Volatile的作用
<em>volatile</em> 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是 synchronized 的一部分。
volatile修饰的变量
<em>volatile</em><em>修饰</em>的确实是一个变量,而且是一个“容易变”的变量。在每次取这个变量值的时候,要求不是取它上次在某个时候取的临时缓存变量(比如说暂存在某个寄存器中),而是直接到内存中取。  <em>volatile</em>变量能防止优化,别如说你在某个地方可能连续调用了好几次这个函数,于是编译器优化后,可能就调用一次,其他几次就采用这一次调用的返回值,而<em>volatile</em><em>修饰</em>后,要让每一次都进行函数调用,  而不
深入理解Java虚拟机笔记---volatile变量的特殊规则
当一个变量定义成<em>volatile</em>之后,它将具备两种特性:第一是保证此变量对所有线程的可见性,这里的“可见性”是指当一条线程修改了这个变量的值,新值对于其它线程是可以立即得知的,变量值在线程间传递均需要通过主内存来完成,如:线程A修改一个普通变量的值,然后向主内存进行回写,另外一条线程B在线程A回写完成了之后再从主内存进行读取操作,新变量的值才会对线程B可见。    <em>关于</em><em>volatile</em>变量的可见
const 和 volatile 成员函数、mutable 数据成员
const 和 <em>volatile</em> 成员函数、mutable 数据成员        为尊重类对象的常量性,编译器必须区分不安全与安全的成员函数(即区分试图修改类对象与不试图修改类对象的函数)。       const成员函数:       类的设计者通过把成员函数声明为 const ,以表明它们不修改类对象。只有被声明为 const 的成员函数才能被一个 const 类
volatile 修饰的属性,在多线程修改下,也是线程不安全的
<em>volatile</em> <em>修饰</em>的对象,在多线程修改下,也是线程不安全的   package ThreadTest; public class ThreadTest3 { public static void main(String args[]){ MyThread mt = new MyThread() ; // 定义线程对象 Th...
嵌入式编程(以STM32为例)中的volatile,const意义及应用场景
__I、 __O 、__IO是什么意思? 这是ST库里面的宏定义,定义如下: #define     __I       <em>volatile</em> const        /*! #define     __O       <em>volatile</em>                  /*! #define     __IO      <em>volatile</em>                  /*!
探究java多线程中正确的单例模式 volatile关键字
关键点是volite关键字的作用 单例模式的实现: 1.饿汉模式 public class Singleton { private static Singleton instance=new Singleton(); private Singleton(){ } public static Singleton getInstance(){ return insta
volatile非线程安全解析
Java内存模型 <em>java</em>使用的是共享变量模型,如下图所示   线程1要读取线程2修改后的值必须要线程2写回到内存,线程1再读取。 Jvm又是如何读取主存变量到线程中的呢?   内存间的相互操作 lock 将对象变成线程独占的状态 unlock 将线程独占状态的对象的锁释放出来 read 从主内存读数据 load 将从主内存读取的数据写入工作内存 use 工作内存使用对象 ...
__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
javavolatile或AtomicBoolean实现高效并发处理 (只初始化一次的功能要求)
最近碰到一个这样的功能要求:实现高效并发处理,只初始化一次.       实现方式: 1)
正确使用Volatile关键字
Java 语言中的 <em>volatile</em> 变量可以被看作是一种 “程度较轻的 synchronized”;与 synchronized 块相比,<em>volatile</em> 变量所需的编码较少,并且运行时开销也较少,但是它所能实现的功能也仅是synchronized 的一部分。本文介绍了几种有效使用 <em>volatile</em> 变量的模式,并强调了几种不适合使用 <em>volatile</em> 变量的情形。 锁提供了两种主
Volatile关键字与线程安全
<em>volatile</em>和多线程资源访问控制分别介绍 一、<em>volatile</em>关键字: <em>volatile</em>关键字,它的语义有二: 1. <em>volatile</em><em>修饰</em>的变量对于其他线程具有立即可见性,即该值发生变化时,其他线程可以立马知道。而普通变量,值发生变化后,需要经过store、write将变量从当前线程的工作副本写入主内存,其他线程再从主内存通过read、load将变量同步到自己的工作内存,由于时
为什么volatile不能保证原子性
这里面涉及<em>volatile</em>,是<em>java</em>中的一个我觉得这个词在Java规范中从未被解释清楚的神奇关键词,在Sun的JDK官方文档是这样形容<em>volatile</em>的: The Java programming language provides a second mechanism, <em>volatile</em> fields, that is more convenient than locking for s
volatile变量修饰符—意料之外的问题(含代码)
转载请注明出处:http://blog.csdn.net/ns_code/article/details/17101369     <em>volatile</em>用处说明     在JDK1.2之前,Java的内存模型实现总是从主存(即共享内存)读取变量,是不需要进行特别的注意的。而随着JVM的成熟和优化,现在在多线程环境下<em>volatile</em>关键字的使用变得非常重要。 在当前的Java内存模型下
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
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...
C++多线程有必要加volatile么?
1<em>volatile</em>的作用是: 作为指令关键字,确保本条指令不会因编译器的优化而省略, 且要求每次直接读值.简单地说就是防止编译器对代码进行优化.比如如下程序: XBYTE[2] = 0x55; XBYTE[2] = 0x56; XBYTE[2] = 0x57; XBYTE[2] = 0x58; 对外部硬件而言,上述四条语句分别表示不同的操作,会产生四种不同的动作,
还在使用 Synchronized同步?试试 Volatile 吧,让你的代码更高效
Synchronized 运用synchronized关键字来实现同步块,大家都比较熟悉。为了避免多线程 同一时间 访问 同一方法或代码块时,方法产生和预期不同的结果,我们一般在这一方法或者代码块前使用synchronized关键字来<em>修饰</em>,从而保证方法或者代码块同一时刻只能有一个线程可以使用。 synchronized 三大特性:地址 地址 可见性:synchronized能够保证同步块
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>...
AtomicInteger的并发处理,Volatile修饰的成员变量
AtomicInteger 通俗地解释: 对某个内存值拷贝一个副本,某个线程若读到该副本,并对其进行计算,输出结果,在写入内存时,再次取出内存值和该副本比较,若副本和内存值相同,则把新的值写入内存。 较为官方的解释: 通过CAS(AtomicInteger)实现,CAS简而言之就是。CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修
[jvm解析系列][七]字段表集合、volatilevolatile和属性表集合,你的变量该如何存储?
上段我们说到一个类的基本构成,今天我们来讲一下类的内部结构。类的内部一般情况下由类的成员变量(类字段),方法和内部类等构成。 1、字段表: 不好意思我们这一次需要先上字段表的内容然后一个一个讲解,不能像前面那样像设计者一样一个一个的推出来了,主要原因还是字段表里包含了属性表。 access_flags 还记得我们在上一篇里讲的,在类的继承关系之后应该就是field_info他主要描
每日一练—C++专项练习 7.18
1、结构化程序设计所规定的三种基本控制结构是顺序、选择、输出。请问这句话对吗() 错误。三种基本控制结构是顺序,选择,循环。   2、int (*p)[6];它的含义是() A、具有6个元素的一维数组 B、定义了一个指向具有6个元素的一维数组的指针变量 C、指向整型指针变量 D、指向6个整数中的一个的地址 选B。A int p[6];  C int p;  int (*p)[6]...
volatile 使用误区
<em>volatile</em>
嵌入式中volatile关键字
<em>volatile</em>关键字区分C程序员和嵌入式系统程序员的最基本的<em>问题</em>:嵌入式系统程序员经常同硬件、中断、RTOS等等打交道,所有这些都要求使用<em>volatile</em>变量。不懂得<em>volatile</em>内容将会带来灾难。     <em>volatile</em>的作用是作为指令关键字,确保本条指令不会因编译器的优化而省略,且要求每次直接读值。如果没有<em>volatile</em>关键字,则编译器可能优化读取和存储,可能暂时使用寄存器中的值
C基础,计算机中的数以及volatile限定修饰符,指针及其注意事项,external,static,Void *
在C语言中可以用<em>volatile</em>限定符<em>修饰</em>变量,就是告诉编译器,即使在编译时指定了优化选项,每次读这个变量仍然要老老实实从内存读取,每次写这个变量也仍然要老老实实写回内存,不能省略任何步骤。
volatile关键字防止变量被编译器优化
<em>volatile</em>是在C,C++,Java等中语言中的一种<em>修饰</em>关键字。 这个关键字在嵌入式系统中,是一个非常重要的一个使用。尽管在一般的Application中,可能很多人都不需要使用这个。但是在单片机中,如果不熟悉这个关键字,很有可能产生想像不到的意外。 那么,我就来谈谈Volatile的意义--<em>volatile</em>在ANSIC(C89)以后的C标准规格和const一起被包含在内。在标准C中,这些
Java多线程复习与巩固(九)--volatile关键字与CAS操作
前一篇文章中提到原子操作,也许大家和我一样很好奇为什么AtomicInteger.increment方法能保证原子性,而简单的++运算却不能保证原子性。这篇文章我们就从AtomicInteger类下手分析源码,来了解一下原子操作的实现原理,但是分析源码之前需要来一段小小的前奏。 CPU内存架构 现代计算机都是多处理机CPU,每个核心(Core)都有一套寄存器,CPU访问寄存器的速度是最快的...
C++中的关键字 volatile 详解
突然想到一个解释<em>volatile</em>关键字的很好的例子。就当做引子,来讲一讲这个关键字吧。 const int iNum = 0; int *iPtr = const_cast(&iNum); *iPtr = 5; cout << "iNum = "<< iNum << endl; cout << "*iPtr = " << *iPtr << endl; cout << "addr iNum: "
scala类型系统:18) 不稳定(volatile)类型
转载自:http://hongjiang.info/scala/ 推荐大家阅读下这位大哥出版的书《Scala函数式编程》
const与volatile关键字的用法
const最主要的特点就是只读,有常量、常量指针,如果不是特别小心的分析C语言语句的书写格式,再加上指针的使用,就特别容易弄错。 <em>volatile</em>关键字是一个类型<em>修饰</em>符,用它声明的<em>类型变量</em>表示可以被某些编译器未知的因素更改,比如:操作系统、硬件或者其它线程等。遇到这个关键字声明的变量,编译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问;如果不使用valatile,则编译
多线程读写共享变量时,synchronized与volatile的作用
在《effective <em>java</em>》中看的的知识点,在工作中确实遇到了~ 关键字synchronized可以保证在同一时刻,只有一个线程可以执行某一个方法,或者某一个代码块。 同步并不是单单指线程之间的互斥。如果没有同步,一个线程的变化就不能被其他线程看到。同步不仅可以阻止一个线程看到对象处于不一致的状态之中, 它还可以保证进入同步方法或者同步代码块的每个线程,都看到由同一个锁保护的之前的所
文章热词 Java 双目视觉问题 特征点问题 相机标定问题 最优化问题
相关热词 volatile关键字的作用c++ c++ volatile 多线程 c++ volatile关键字 c++ 关于unique的问题 关于python培训班 关于区块链的课程
我们是很有底线的