volatile

一.前言 　 编译器优化介绍： 　　 由于内存访问速度远不及CPU处理速度，为提高机器整体性能， 1）在硬件上： 引入硬件高速缓存Cache，加速对内存的访问。另外在现代CPU中指令的执行并不一定严格按照顺序执行，没有相关性的指令可以乱序执行，以充分利用CPU的指令流水线，提高执行速度。 2）软件一级的优化：一种是在编写代码时由程序员优化，另一种是由编译器进行优化。 编译器优化常用的方法有：将内存变量缓存到寄存器。 由于访问寄存器要比访问内存单元快的多，编译器在存取变量时，为提高存取速度，编译器优化有时会先把变量读取到一个寄存器中；以后再取变量值时就直接从寄存器中取值。但在很多情况下会读取到脏数据，严重影响程序的运行效果。 ---------------------------------------------------------------------------------------------------------------------------------------------------------------- 二.volatile详解 1.原理作用： 　　Volatile 意思是“易变的”，应该解释为“直接存取原始内存地址”比较合适。 　　“易变”是因为外在因素引起的，像多线程，中断等； 　　C 语言书籍这样定义 volatile 关键字：

原文地址：http://www.ibm.com/developerworks/cn/java/j-jtp06197.html Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized ”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 volatile 变量的模式，并强调了几种不适合使用 volatile 变量的情形。 锁提供了两种主要特性： 互斥（mutual exclusion） 和 可见性（visibility） 。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。 Volatile 变量 Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例

简介： Java™ 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量。这两种机制的提出都是为了实现代码线程的安全性。其中 Volatile 变量的同步性较差（但有时它更简单并且开销更低），而且其使用也更容易出错。在这期的 Java 理论与实践 中，Brian Goetz 将介绍几种正确使用 volatile 变量的模式，并针对其适用性限制提出一些建议。 Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized ”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 volatile 变量的模式，并强调了几种不适合使用 volatile 变量的情形。 锁提供了两种主要特性： 互斥（mutual exclusion） 和 可见性（visibility） 。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值

本文转自：http://www.ibm.com/developerworks/cn/java/j-jtp06197.html 由Java并发大师Brian Goetz所撰写的。 Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized ”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 volatile 变量的模式，并强调了几种不适合使用 volatile 变量的情形。 锁提供了两种主要特性： 互斥（mutual exclusion） 和 可见性（visibility） 。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些， 它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。 Volatile 变量 Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性 。这就是说线程能够自动发现 volatile 变量的最新值。Volatile

Java 语言中的 volatile 变量可以被看作是一种 “程度较轻的 synchronized ”；与 synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是 synchronized 的一部分。本文介绍了几种有效使用 volatile 变量的模式，并强调了几种不适合使用 volatile 变量的情形。 锁提供了两种主要特性： 互斥（mutual exclusion） 和 可见性（visibility） 。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性要更加复杂一些，它必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的 —— 如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。 Volatile 变量 Volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性。这就是说线程能够自动发现 volatile 变量的最新值。Volatile 变量可用于提供线程安全，但是只能应用于非常有限的一组用例：多个变量之间或者某个变量的当前值与修改后值之间没有约束。因此，单独使用 volatile 还不足以实现计数器

volatile和synchronized特点 首先需要理解线程安全的两个方面： 执行控制 和 内存可见 。 执行控制 的目的是控制代码执行（顺序）及是否可以并发执行。 内存可见 控制的是线程执行结果在内存中对其它线程的可见性。根据 Java内存模型 的实现，线程在具体执行时，会先拷贝主存数据到线程本地（CPU缓存），操作完成后再把结果从线程本地刷到主存。 synchronized 关键字解决的是执行控制的问题，它会阻止其它线程获取当前对象的监控锁，这样就使得当前对象中被 synchronized 关键字保护的代码块无法被其它线程访问，也就无法并发执行。更重要的是， synchronized 还会创建一个 内存屏障 ，内存屏障指令保证了所有CPU操作结果都会直接刷到主存中，从而保证了操作的内存可见性，同时也使得先获得这个锁的线程的所有操作，都 happens-before 于随后获得这个锁的线程的操作。 volatile 关键字解决的是内存可见性的问题，会使得所有对 volatile 变量的读写都会直接刷到主存，即保证了变量的可见性。这样就能满足一些对变量可见性有要求而对读取顺序没有要求的需求。 使用 volatile 关键字仅能实现对原始变量(如boolen、 short 、int 、long等)操作的原子性，但需要特别注意， volatile 不能保证复合操作的原子性，即使只是

概述 用Java来开发多线程程序变得越来越常见，虽然Java提供了并发包来简化多线程程序的编写，但是我们有必要深入研究一下，才能更好的掌握这块知识。 本文主要对Java提供的底层原语synchronized和volatile进行分析，看看他们究竟干了什么，以及怎么样才能合理的使用它们。 运算速度与IO速度的问题 现代计算机模型，待计算的数据主要存储在内存中，CPU想要对数据进行计算，就必须要经过下面的流程：从内存读取数据-->CPU计算-->把计算结果写回内存。但是，不得不承认一个事实，就是CPU与内存之间的IO速度，要比CPU的运算速度慢很多，所以这样就不能充分发挥CPU的计算能力。 为了解决这个问题，引入了高速缓存的概念，它一般位于内存与CPU之间，与CPU之间有较高的IO速度。高速缓存存放常用的数据，这样就可以大幅度提高CPU的利用率。 由缓存命中问题引出的指令重排序 上面提到了高速缓存之间的概念。既然提到高速缓存，那么就要谈到缓存命中的问题，如果缓存命中率很高，那么整体性能就会提升。所以，试想一下，有下面几行代码： int a = 0; a = a + 10; int b = 0; b = b + 5; a = a * 2; 通常我们会认为，执行完第2条代码后，a被写入到高速缓存，然后执行对b的操作，最后再从高速缓存中读取出a，再对a做乘法计算。 但是

注：本文为个人学习摘录，原文地址：http://www.cnblogs.com/gjhjoy/p/3556709.html 恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码： int i1 ; int geti1 () { return i1 ; } volatile int i2 ; int geti2 () { return i2 ; } int i3 ; synchronized int geti3 () { return i3 ; } 　　geti1()得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改 变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程 可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值 是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。 　 　而geti2()得到的是“主

一、不得不提的volatile volatile是个很老的关键字，几乎伴随着JDK的诞生而诞生，我们都知道这个关键字，但又不太清楚什么时候会使用它；我们在JDK及开源框架中随处可见这个关键字，但并发专家又往往建议我们远离它。比如Thread这个很基础的类，其中很重要的线程状态字段，就是用volatile来修饰，见代码 /* Java thread status for tools, * initialized to indicate thread 'not yet started' */ private volatile int threadStatus = 0; */ /*--> */ 如上面所说，并发专家建议我们远离它，尤其是在JDK6的synchronized关键字的性能被大幅优化之后，更是几乎没有使用它的场景，但这仍然是个值得研究的关键字，研究它的意义不在于去使用它，而在于理解它对理解Java的整个多线程的机制是很有帮助的。 1. 例子 先来体会一下volatile的作用，从下面代码开始 1: public class VolatileExample extends Thread{ 2: //设置类静态变量,各线程访问这同一共享变量 3: private static boolean flag = false; 4: 5: //无限循环,等待flag变为true时才跳出循环

JMM： 　　Java Memory Model(Java内存模型)，围绕着在并发过程中如何处理 可见性 、 原子性 、 有序性 这三个特性而建立的模型。 可见性： 　　JMM提供了volatile变量定义、final、synchronized块来保证可见性。 　　例如：线程a在将共享变量x=1写入主内存的时候，如何保证线程b读取共享变量x的值为1，这就是JMM做的事情。JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证。 原子性： 　　JMM提供保证了访问基本数据类型的原子性（其实在写一个工作内存变量到主内存是分主要两步：store、write），但是实际业务处理场景往往是需要更大的范围的原子性保证，所以模型也提供了 synchronized 块来保证。 有序性： 　　这个概念是相对而言的，如果在本线程内，所有的操作都是有序的，如果在一个线程观察另一个线程，所有的操作都是无序的，前句是“线程内表现为串行行为”，后句是“指令的重排序”和“工作内存和主内存同步延迟”现象，模型提供了 volatile和synchronized来保证线程之间操作的有序性 。 重排序： 　　在执行程序时为了提高性能，编译器和处理器常常会对指令做重排序(编译器、处理器)，就是因为这些重排序，所以可能会导致多线程程序出现内存可见性问题(数据安全问题)和有序性问题。