volatile什么意思java java的volatile是什么意思

今天给各位分享volatile什么意思java的知识，其中也会对java的volatile是什么意思进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

java里volatile关键字有什么特性

Java语言中关键字 volatile被称作轻量级的 synchronized，与synchronized相比，volatile编码相对简单且运行的时的开销较少，但能够正确合理的应用好 volatile并不是那么的容易，因为它比使用锁更容易出错，接下来本文主要介绍 volatile的使用准则，以及使用过程中需注意的地方。

为何使用volatile？

（1）简易性：在某些需要同步的场景下使用volatile变量要比使用锁更加简单

（2）性能：在某些情况下使用volatile同步机制的性能要优于锁

（3）volatile操作不会像锁一样容易造成阻塞

volatile特性

（1）volatile变量具有 synchronized的可见性特性，及如果一个字段被声明为volatile，java线程内存模型确保所有的线程看到这个变量的值是一致的

（2）禁止进行指令重排序

（3）不保证原子性

注：

①重排序：重排序通常是编译器或运行时环境为了优化程序性能而采取的对指令进行重新排序执行的一种手段

②原子性：不可中断的一个或一系列操作

③可见性：锁提供了两种主要特性：互斥和可见性，互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的。

volatile的实现原理

如果对声明了volatile的变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，该Lock指令会使这个变量所在缓存行的数据回写到系统内存，根据缓存一致性协议，每个处理器都会通过嗅探在总线上传输的数据来检查自己缓存的值是否已过期，当处理器发现自己的缓存行对应的地址被修改，就会将当前处理器的缓存行设置成无效状态，在下次访问相同内存地址时，强制执行缓存行填充。

正确使用volatile的场景

volatile主要用来解决多线程环境中内存不可见问题。对于一写多读，是可以解决变量同步问题，但是如果多写，就无法解决线程安全问题。如：

1、不适合使用volatile的场景（非原子性操作）

（1）反例

private static volatile int nextSerialNum= 0;

public static long generateSerialNum(){

return nextSerialNum++;

}

这个方法的目的是要确保每次调用都返回不同的自增值，然而结果并不理想，问题在于增量操作符（++）不是原子操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，如果第二个线程在第一个线程读取旧值和写回新值期间读取这个域，第二个线程与第一个线程就会读取到同一个值。

（2）正例

其实面对上面的反例场景可以使用JDK1.5 java.util.concurrent.atomic中提供的原子包装类型来保证原子性操作

private static AtomicInteger nextSerialNum= new AtomicInteger(0);

public static long generateSerialNum(){

return nextSerialNum.getAndIncrement();

}

2、适合使用volatile的场景

在日常工作当中volatile大多被在状态标志的场景当中，如：

要通过一个线程来终止另外一个线程的场景

（1）反例

private static boolean stopThread;

public static void main(String[] args) throws InterruptedException{

Thread th= new Thread(new Runnable(){

@Override

public void run(){

int i= 0;

while(!stopThread){

i++;

}

}

});

th.start();

TimeUnit.SECONDS.sleep(2);

stopThread= true;

}

运行后发现该程序根本无法终止循环，原因是，java语言规范并不保证一个线程写入的值对另外一个线程是可见的，所以即使主线程main函数修改了共享变量stopThread状态，但是对th线程并不一定可见，最终导致循环无法终止。

（2）正例

private static volatile boolean stopThread;

public static void main(String[] args) throws InterruptedException{

Thread th= new Thread(new Runnable(){

@Override

public void run(){

int i= 0;

while(!stopThread){

i++;

}

}

});

th.start();

TimeUnit.SECONDS.sleep(2);

stopThread= true;

}

通过使用关键字volatile修饰共享变量stopThread，根据volatile的可见性原则可以保证主线程main函数修改了共享变量stopThread状态后对线程th来说是立即可见的，所以在两秒内线程th将停止循环。

java的volatile是什么意思

volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示vm：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了vm中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

就跟c中的一样

禁止编译器进行优化~~~~

Java:volatile的作用是什么呢我的理解正确吗

一个定义为volatile的变量是说这变量可能会被意想不到地改变，这样，编译器就不会去假设这个变量的值了。精确地说就是，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。下面是volatile变量的几个例子：

1）.并行设备的硬件寄存器（如：状态寄存器）

2）.一个中断服务子程序中会访问到的非自动变量（Non-automatic variables)

3）.多线程应用中被几个任务共享的变量

这是区分C程序员和嵌入式系统程序员的最基本的问题：嵌入式系统程序员经常同硬件、中断、RTOS等等打交道，所有这些都要求使用volatile变量。不懂得volatile内容将会带来灾难。

假设被面试者正确地回答了这是问题（嗯，怀疑是否会是这样），我将稍微深究一下，看一下这家伙是不是真正懂得volatile完全的重要性。

1）.一个参数既可以是const还可以是volatile吗？解释为什么。

2）.一个指针可以是volatile吗？解释为什么。

3）.下面的函数被用来计算某个整数的平方，它能实现预期设计目标吗？如果不能，试回答存在什么问题：

1

2

3

4

int square( volatile int*ptr)

{

return*ptr**ptr;

}

下面是答案：

1）.是的。一个例子是只读的状态寄存器。它是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

2）.是的。尽管这并不很常见。一个例子是当一个中断服务子程序修改一个指向一个buffer的指针时。

3）.这段代码是个恶作剧。这段代码的目的是用来返指针*ptr指向值的平方，但是，由于*ptr指向一个volatile型参数，编译器将产生类似下面的代码：

1

2

3

4

5

6

7

int square( volatile int*ptr)

{

int a,b;

a=*ptr;

b=*ptr;

return a* b;

}

由于*ptr的值可能在两次取值语句之间发生改变，因此a和b可能是不同的。结果，这段代码可能返回的不是你所期望的平方值！正确的代码如下：

1

2

3

4

5

6

long square( volatile int*ptr)

{

int a;

a=*ptr;

return a* a;

}

讲讲个人理解：

关键在于两个地方：

⒈编译器的优化（请高手帮我看看下面的理解）

在本次线程内，当读取一个变量时，为提高存取速度，编译器优化时有时会先把变量读取到一个寄存器中；以后再取变量值时，就直接从寄存器中取值；

当变量值在本线程里改变时，会同时把变量的新值copy到该寄存器中，以便保持一致

当变量在因别的线程等而改变了值，该寄存器的值不会相应改变，从而造成应用程序读取的值和实际的变量值不一致

当该寄存器在因别的线程等而改变了值，原变量的值不会改变，从而造成应用程序读取的值和实际的变量值不一致

举一个不太准确的例子：

发薪资时，会计每次都把员工叫来登记他们的银行卡号；一次会计为了省事，没有即时登记，用了以前登记的银行卡号；刚好一个员工的银行卡丢了，已挂失该银行卡号；从而造成该员工领不到工资

员工－－原始变量地址

银行卡号－－原始变量在寄存器的备份

⒉在什么情况下会出现

1）.并行设备的硬件寄存器

2）.一个中断服务子程序中会访问到的非自动变量（Non-automatic variables)

3）.多线程应用中被几个任务共享的变量

补充：volatile应该解释为“直接存取原始内存地址”比较合适，“易变的”这种解释简直有点误导人；

“易变”是因为外在因素引起的，像多线程，中断等，并不是因为用volatile修饰了的变量就是“易变”了，假如没有外因，即使用volatile定义，它也不会变化；

而用volatile定义之后，其实这个变量就不会因外因而变化了，可以放心使用了；大家看看前面那种解释（易变的）是不是在误导人

volatile关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

使用该关键字的例子如下：

1

int volatile nVint;

当要求使用volatile声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。

例如：

1

2

3

volatile int i=10;

int a= i;

//...

//其他代码，并未明确告诉编译器，对i进行过操作

1

int b= i;

volatile指出 i是随时可能发生变化的，每次使用它的时候必须从i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在b中。而优化做法是，由于编译器发现两次从i读数据的代码之间的代码没有对i进行过操作，它会自动把上次读的数据放在b中。而不是重新从i里面读。这样一来，如果i是一个寄存器变量或者表示一个端口数据就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

注意，在vc6中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无volatile关键字，对程序最终代码的影响：

首先，用classwizard建一个win32 console工程，插入一个voltest.cpp文件，输入下面的代码：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

#include<stdio.h>

void main( int argc, char* argv[])

{

int i= 10;

int a= i;

printf("i=%d", a);

//下面汇编语句的作用就是改变内存中i的值，但是又不让编译器知道

__asm

{

mov dword ptr [ebp-4], 20h

}

int b= i;

printf("i=%d", b);

}

然后，在调试版本模式运行程序，输出结果如下：

i= 10

i= 32

然后，在release版本模式运行程序，输出结果如下：

i= 10

i= 10

输出的结果明显表明，release模式下，编译器对代码进行了优化，第二次没有输出正确的i值。下面，我们把 i的声明加上volatile关键字，看看有什么变化：

1

2

3

4

5

6

7

8

9

10

11

12

13

#include<stdio.h>

void main( int argc, char* argv[])

{

volatile int i=10;

int a= i;

printf("i=%d", a);

__asm

{

mov dword ptr [ebp-4], 20h

}

int b= i;

printf("i=%d", b);

}

分别在调试版本和release版本运行程序，输出都是：

i= 10

i= 32

这说明这个关键字发挥了它的作用！

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

volatile对应的变量可能在你的程序本身不知道的情况下发生改变

比如多线程的程序，共同访问的内存当中，多个程序都可以操纵这个变量

你自己的程序，是无法判定何时这个变量会发生变化

还比如，他和一个外部设备的某个状态对应，当外部设备发生操作的时候，通过驱动程序和中断事件，系统改变了这个变量的数值，而你的程序并不知道。

对于volatile类型的变量，系统每次用到他的时候都是直接从对应的内存当中提取，而不会利用cache当中的原有数值，以适应它的未知何时会发生的变化，系统对这种变量的处理不会做优化——显然也是因为它的数值随时都可能变化的情况。

java编程,如何彻底理解volatile关键字

非java程序员，不过volatile在其他语言中也存在，简单说下。

1，volatile只在多线程程序中有意义。

2，为了提高性能，编译器工作时会进行一些优化，如指令排序，甚至跳过一些指令。如:

var

a=1；

a=2；

a=3；

编译后的结果可能就只执行

a

=

3

3，程序运行时，普通变量会有缓存机制（如cpu缓存、线程本地缓存等），程序读取时先从缓存读取，所以多线程的程序运行时可能存在脏读问题。即第一个线程已经修改了变量值，但第二个线程还在使用缓存中的旧数据。

volatile的作用就是告诉编译器，不要对使用该变量的代码进行优化，每次读写操作都访问变量的原始数据。

OK，本文到此结束，希望对大家有所帮助。