14.深入分析Volatile的实现原理

13.java多线程编程底层原理剖析以及volatile原理

12.Java中Volatile底层原理与应用

11.volatile底层实现原理

===================

14.深入分析Volatile的实现原理

引言

在多线程并发编程中synchronized和Volatile都扮演着重要的角色，Volatile是 轻量级的synchronized ，它在多处理器开发中保证了共享变量的“可见性”。

可见性的意思是当一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。

它在某些情况下比synchronized的开销更小，本文将深入分析在硬件层面上Inter处理器是如何实现Volatile的，通过深入分析能帮助我们正确的使用Volatile变量。

1. public class VolatileTest extends Thread{
2. public  static volatile  int a=0;
3. public void run() {
4. a++;
5. }
6. public static void main(String[] args) {
7. VolatileTest array[]=new VolatileTest[10000];
8. for (int i = 0; i < array.length; i++) {
9. array[i]=new VolatileTest();
10. array[i].start();
11. }
12. System.out.println(VolatileTest.a);
13. }
14. }

术语定义

Volatile的官方定义

Java语言规范第三版中对volatile的定义如下： java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致的更新，线程应该确保通过排他锁单独获得这个变量。Java语言提供了volatile，在某些情况下比锁更加方便。如果一个字段被声明成volatile，java线程内存模型确保所有线程看到这个变量的值是一致的。

为什么要使用Volatile

Volatile变量修饰符如果使用 恰当 的话，它比synchronized的 使用和执行成本会更低 ，因为它不会引起线程上下文的切换和调度。

Volatile的实现原理

那么Volatile是如何来保证可见性的呢？在x86处理器下通过工具获取JIT编译器生成的汇编指令来看看对Volatile进行写操作CPU会做什么事情。

有volatile变量修饰的共享变量进行写操作的时候会多第二行汇编代码，通过查IA-32架构软件开发者手册可知，lock前缀的指令在多核处理器下会引发了两件事情。

• 将当前处理器缓存行的数据会写回到系统内存。
• 这个写回内存的操作会引起在其他CPU里缓存了该内存地址的数据无效。

处理器为了提高处理速度，不直接和内存进行通讯，而是先将系统内存的数据读到内部缓存（L1,L2或其他）后再进行操作，但操作完之后不知道何时会写到内存，如果对声明了Volatile变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。但是就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题，所以在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器要对这个数据进行修改操作的时候，会强制重新从系统内存里把数据读到处理器缓存里。

这两件事情在IA-32软件开发者架构手册的第三册的多处理器管理章节（第八章）中有详细阐述。

Lock前缀指令会引起处理器缓存回写到内存 。Lock前缀指令导致在执行指令期间，声言处理器的 LOCK# 信号。在多处理器环境中，LOCK# 信号确保在声言该信号期间，处理器可以独占使用任何共享内存。（因为它会锁住总线，导致其他CPU不能访问总线，不能访问总线就意味着不能访问系统内存），但是在最近的处理器里，LOCK＃信号一般不锁总线，而是锁缓存，毕竟锁总线开销比较大。在8.1.4章节有详细说明锁定操作对处理器缓存的影响，对于Intel486和Pentium处理器，在锁操作时，总是在总线上声言LOCK#信号。但在P6和最近的处理器中，如果访问的内存区域已经缓存在处理器内部，则不会声言LOCK#信号。相反地，它会锁定这块内存区域的缓存并回写到内存，并使用缓存一致性机制来确保修改的原子性，此操作被称为“缓存锁定”，缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据 。

一个处理器的缓存回写到内存会导致其他处理器的缓存无效 。IA-32处理器和Intel 64处理器使用MESI（修改，独占，共享，无效）控制协议去维护内部缓存和其他处理器缓存的一致性。在多核处理器系统中进行操作的时候，IA-32 和Intel 64处理器能嗅探其他处理器访问系统内存和它们的内部缓存。它们使用嗅探技术保证它的内部缓存，系统内存和其他处理器的缓存的数据在总线上保持一致。例如在Pentium和P6 family处理器中，如果通过嗅探一个处理器来检测其他处理器打算写内存地址，而这个地址当前处理共享状态，那么正在嗅探的处理器将无效它的缓存行，在下次访问相同内存地址时，强制执行缓存行填充。

Volatile的使用优化

著名的Java并发编程大师Doug lea在JDK7的并发包里新增一个队列集合类LinkedTransferQueue，他在使用Volatile变量时，用一种追加字节的方式来优化队列出队和入队的性能。

追加字节能优化性能？这种方式看起来很神奇，但如果深入理解处理器架构就能理解其中的奥秘。让我们先来看看LinkedTransferQueue这个类，它使用一个内部类类型来定义队列的头队列（Head）和尾节点（tail），而这个内部类PaddedAtomicReference相对于父类AtomicReference只做了一件事情，就将共享变量追加到64字节。我们可以来计算下，一个对象的引用占4个字节，它追加了15个变量共占60个字节，再加上父类的Value变量，一共64个字节。

/** head of the queue */

private transient final PaddedAtomicReference < QNode > head;

/** tail of the queue */

private transient final PaddedAtomicReference < QNode > tail;

static final class PaddedAtomicReference < T > extends AtomicReference < T > {

  // enough padding for 64bytes with 4byte refs

  Object p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, pa, pb, pc, pd, pe;

  PaddedAtomicReference(T r) {

    super(r);

  }

}

public class AtomicReference < V > implements java.io.Serializable {

  private volatile V value;

  //省略其他代码 ｝

为什么追加64字节能够提高并发编程的效率呢 ？ 因为对于英特尔酷睿i7，酷睿， Atom和NetBurst， Core Solo和Pentium M处理器的L1，L2或L3缓存的高速缓存行是64个字节宽，不支持部分填充缓存行，这意味着如果队列的头节点和尾节点都不足64字节的话，处理器会将它们都读到同一个高速缓存行中，在多处理器下每个处理器都会缓存同样的头尾节点，当一个处理器试图修改头接点时会将整个缓存行锁定，那么在缓存一致性机制的作用下，会导致其他处理器不能访问自己高速缓存中的尾节点，而队列的入队和出队操作是需要不停修改头接点和尾节点，所以在多处理器的情况下将会严重影响到队列的入队和出队效率。Doug lea使用追加到64字节的方式来填满高速缓冲区的缓存行，避免头接点和尾节点加载到同一个缓存行，使得头尾节点在修改时不会互相锁定。

那么是不是在使用Volatile变量时都应该追加到64字节呢？不是的。在两种场景下不应该使用这种方式。第一： 缓存行非64字节宽的处理器 ，如P6系列和奔腾处理器，它们的L1和L2高速缓存行是32个字节宽。第二： 共享变量不会被频繁的写 。因为使用追加字节的方式需要处理器读取更多的字节到高速缓冲区，这本身就会带来一定的性能消耗，共享变量如果不被频繁写的话，锁的几率也非常小，就没必要通过追加字节的方式来避免相互锁定。

原子操作的实现原理

1. 引言

原子（atom）本意是“不能被进一步分割的最小粒子”，而原子操作（atomic operation）意为"不可被中断的一个或一系列操作" 。在多处理器上实现原子操作就变得有点复杂。本文让我们一起来聊一聊在Intel处理器和Java里是如何实现原子操作的。

2. 术语定义

3. 处理器如何实现原子操作

32位IA-32处理器使用基于对缓存加锁或总线加锁的方式来实现多处理器之间的原子操作。

3.1 处理器自动保证基本内存操作的原子性

首先处理器会自动保证基本的内存操作的原子性。处理器保证从系统内存当中读取或者写入一个字节是原子的，意思是当一个处理器读取一个字节时，其他处理器不能访问这个字节的内存地址。奔腾6和最新的处理器能自动保证单处理器对同一个缓存行里进行16/32/64位的操作是原子的，但是复杂的内存操作处理器不能自动保证其原子性，比如跨总线宽度，跨多个缓存行，跨页表的访问。但是处理器提供总线锁定和缓存锁定两个机制来保证复杂内存操作的原子性。

3.2 使用总线锁保证原子性

第一个机制是通过总线锁保证原子性。如果多个处理器同时对共享变量进行读改写（i++就是经典的读改写操作）操作，那么共享变量就会被多个处理器同时进行操作，这样读改写操作就不是原子的，操作完之后共享变量的值会和期望的不一致，举个例子：如果i=1,我们进行两次i++操作，我们期望的结果是3，但是有可能结果是2。如下图

（例1）

原因是有可能多个处理器同时从各自的缓存中读取变量i，分别进行加一操作，然后分别写入系统内存当中。那么想要保证读改写共享变量的操作是原子的，就必须保证CPU1读改写共享变量的时候，CPU2不能操作缓存了该共享变量内存地址的缓存。

处理器使用总线锁就是来解决这个问题的。所谓总线锁就是使用处理器提供的一个LOCK＃信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住,那么该处理器可以独占使用共享内存。

3.3 使用缓存锁保证原子性

第二个机制是通过缓存锁定保证原子性。在同一时刻我们只需保证对某个内存地址的操作是原子性即可，但总线锁定把CPU和内存之间通信锁住了，这使得锁定期间，其他处理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，最近的处理器在某些场合下使用缓存锁定代替总线锁定来进行优化。

频繁使用的内存会缓存在处理器的L1，L2和L3高速缓存里，那么原子操作就可以直接在处理器内部缓存中进行，并不需要声明总线锁，在奔腾6和最近的处理器中可以使用“缓存锁定”的方式来实现复杂的原子性。所谓“缓存锁定”就是如果缓存在处理器缓存行中内存区域在LOCK操作期间被锁定，当它执行锁操作回写内存时，处理器不在总线上声言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子性，因为缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据，当其他处理器回写已被锁定的缓存行的数据时会起缓存行无效，在例1中，当CPU1修改缓存行中的i时使用缓存锁定，那么CPU2就不能同时缓存了i的缓存行。

但是有两种情况下处理器不会使用缓存锁定。第一种情况是：当操作的数据不能被缓存在处理器内部，或操作的数据跨多个缓存行（cache line），则处理器会调用总线锁定。第二种情况是：有些处理器不支持缓存锁定。对于Inter486和奔腾处理器,就算锁定的内存区域在处理器的缓存行中也会调用总线锁定。

以上两个机制我们可以通过Inter处理器提供了很多LOCK前缀的指令来实现。比如位测试和修改指令BTS，BTR，BTC，交换指令XADD，CMPXCHG和其他一些操作数和逻辑指令，比如ADD（加），OR（或）等，被这些指令操作的内存区域就会加锁，导致其他处理器不能同时访问它。

4. JAVA如何实现原子操作

在java中可以通过锁和循环CAS的方式来实现原子操作。

4.1 使用循环CAS实现原子操作

JVM中的CAS操作正是利用了上一节中提到的处理器提供的CMPXCHG指令实现的。自旋CAS实现的基本思路就是循环进行CAS操作直到成功为止，以下代码实现了一个基于CAS线程安全的计数器方法safeCount和一个非线程安全的计数器count。

public class Counter {

  private AtomicInteger atomicI = new AtomicInteger(0);

  private int i = 0;

  public static void main(String[] args) {

    final Counter cas = new Counter();

    List<Thread> ts = new ArrayList<Thread>(600);

    long start = System.currentTimeMillis();

    for (int j = 0; j < 100; j++) {

      Thread t = new Thread(new Runnable() {

        @Override

        public void run() {

          for (int i = 0; i < 10000; i++) {

            cas.count();

            cas.safeCount();

          }

        }

      });

      ts.add(t);

    }

    for (Thread t : ts) {

      t.start();

    }

     // 等待所有线程执行完成

    for (Thread t : ts) {

      try {

        t.join();

      } catch (InterruptedException e) {

        e.printStackTrace();

      }

    }

    System.out.println(cas.i);

    System.out.println(cas.atomicI.get());

    System.out.println(System.currentTimeMillis() - start);

  }

  /**

   * 使用CAS实现线程安全计数器

   */

  private void safeCount() {

    for (;;) {

      int i = atomicI.get();

      boolean suc = atomicI.compareAndSet(i, ++i);

      if (suc) {

        break;

      }

    }

  }

  /**

   * 非线程安全计数器

   */

  private void count() {

    i++;

  }

}

在java并发包中有一些并发框架也使用了自旋CAS的方式来实现原子操作，比如LinkedTransferQueue类的Xfer方法。CAS虽然很高效的解决原子操作，但是CAS仍然存在三大问题。ABA问题，循环时间长开销大和只能保证一个共享变量的原子操作。

1. ABA问题。因为CAS需要在操作值的时候检查下值有没有发生变化，如果没有发生变化则更新，但是如果一个值原来是A，变成了B，又变成了A，那么使用CAS进行检查时会发现它的值没有发生变化，但是实际上却变化了。ABA问题的解决思路就是使用版本号。在变量前面追加上版本号，每次变量更新的时候把版本号加一，那么A－B－A 就会变成1A-2B－3A。 
   从Java1.5开始JDK的atomic包里提供了一个类AtomicStampedReference来解决ABA问题。这个类的compareAndSet方法作用是首先检查当前引用是否等于预期引用，并且当前标志是否等于预期标志，如果全部相等，则以原子方式将该引用和该标志的值设置为给定的更新值。

   public boolean compareAndSet
   
           (V      expectedReference,//预期引用
   
            V      newReference,//更新后的引用
   
           int    expectedStamp, //预期标志
   
           int    newStamp) //更新后的标志

2. 循环时间长开销大。自旋CAS如果长时间不成功，会给CPU带来非常大的执行开销。如果JVM能支持处理器提供的pause指令那么效率会有一定的提升，pause指令有两个作用，第一它可以延迟流水线执行指令（de-pipeline）,使CPU不会消耗过多的执行资源，延迟的时间取决于具体实现的版本，在一些处理器上延迟时间是零。第二它可以避免在退出循环的时候因内存顺序冲突（memory order violation）而引起CPU流水线被清空（CPU pipeline flush），从而提高CPU的执行效率。

3. 只能保证一个共享变量的原子操作。当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者有一个取巧的办法，就是把多个共享变量合并成一个共享变量来操作。比如有两个共享变量i＝2,j=a，合并一下ij=2a，然后用CAS来操作ij。从Java1.5开始JDK提供了AtomicReference类来保证引用对象之间的原子性，你可以把多个变量放在一个对象里来进行CAS操作。

4.2 使用锁机制实现原子操作

锁机制保证了只有获得锁的线程能够操作锁定的内存区域。JVM内部实现了很多种锁机制，有偏向锁，轻量级锁和互斥锁，有意思的是除了偏向锁，JVM实现锁的方式都用到的循环CAS，当一个线程想进入同步块的时候使用循环CAS的方式来获取锁，当它退出同步块的时候使用循环CAS释放锁。详细说明可以参见文章Java SE1.6中的Synchronized。

5. 参考资料

1. Java SE1.6中的Synchronized
2. Intel 64和IA-32架构软件开发人员手册
3. 深入分析Volatile的实现原理

作者介绍

方腾飞 ，花名清英，淘宝资深开发工程师，关注并发编程，目前在广告技术部从事无线广告联盟的开发和设计工作。个人博客： http://ifeve.com  微博： http://weibo.com/kirals  欢迎通过我的微博进行技术交流。

http://www.infoq.com/cn/articles/atomic-operation

Linux 原子操作

typedef struct  {  volatile int counter;  }  atomic_t;

atomic_read(atomic_t * v);

atomic_set(atomic_t * v, int i);

void atomic_add(int i, atomic_t *v);

atomic_sub(int i, atomic_t *v);

int atomic_sub_and_test(int i, atomic_t *v);

void atomic_inc(atomic_t *v);

void atomic_dec(atomic_t *v);

int atomic_dec_and_test(atomic_t *v);

int atomic_inc_and_test(atomic_t *v);

int atomic_add_negative(int i, atomic_t *v);

int atomic_add_return(int i, atomic_t *v);

int atomic_sub_return(int i, atomic_t *v);

int atomic_inc_return(atomic_t * v);

int atomic_dec_return(atomic_t * v);

原子操作 函数原型

1. #include <linux/type.h>

2. typedef struct

   {

3. int  counter ;
4. }  atomic_t ;

可以看出整型原子变量实质上是一个32位整型变量。

整型原子变量操作接口，其实现方式与具体的架构有关。

1. #include <asm/atomic.h>

2. ATOMIC_INIT ( int  i )                            // 定义原子变量时，将其值赋为i
3. int  atomic_read ( atomic_t  * v )                  // 读v的值
4. void atomic_set ( atomic_t  * v ,   int  i )           // 设置v的值为i
5. void atomic_add ( int  i ,  atomic  * v )             // v的值增加i
6. void atomic_sub ( int  i ,  atomic  * v )             // v的值减少i
7. void atomic_inc ( atomic  * v )                    // v的值加1
8. void atomic_dec ( atomic  * v )                    // v的值减1
9. int  atomic_sub_and_test ( int  i ,  atomic_t  * v )   // v的值减少i , 且结果为0时返回true
10. int  atomic_add_negative ( int  i ,  atomic_t  * v )   // v的值增加i , 且结果为负数时返回true
11. int  atomic_add_return ( int  i ,  atomic_t  * v )     // v的值增加i , 且返回结果
12. int  atomic_sub_return ( int  i ,  atomic_t  * v )     // v的值减少i , 且返回结果
13. int  atomic_inc_return ( atomic_t  * v )            // v的值加1，且返回结果
14. int  atomic_dec_return ( atomic_t  * v )            // v的值减1，且返回结果
15. int  atomic_dec_and_test ( atomic_t  * v )          // v的值减1，且结果为0时返回true
16. int  atomic_inc_and_test ( atomic_t  * v )          // v的值加1，且结果为0时返回true

2 64位原子操作

（64-Bit Atomic Operations）

64位原子变量结构

1. typedef struct

   {

2. u64 __aligned ( 8 )  counter ;
3. }  atomic64_t ;

64位原子变量操作接口与整型变量操作接口类似，只要将整型变量接口名称的"atomic"改成"atomic64"即可。

3 位原子操作

（Atomic Bitwise Operations）

位原子操作接口

1. #include  < asm / bitops . h

   >

2. void set_bit ( int  nr ,  void  * addr )             / /  将addr第nr位置1
3. void clear_bit ( int  nr ,  void  * addr )           / /  将addr第nr位置0
4. void change_bit ( int  nr ,  void  * addr )          / /  将addr第nr位值取反
5. int  test_and_set_bit ( int  nr ,  void  * addr )     / /  将addr第nr位置1，并将该位之前值返回
6. int  test_and_clear_bit ( int  nr ,  void  * addr )   / /  将addr第nr位置0，并将该位之前值返回
7. int  test_and_change_bit ( int  nr ,  void  * addr ) / /  将addr第nr位取反，并将该位之前值返回

1. int  test_bit ( int  nr ,  void  * addr )     / /  将addr第nr位的值返回

13.java多线程编程底层原理剖析以及volatile原理

今天总结一下java多线程机制，以及volatile

首先，为什么需要多线程？

主要是因为计算机的运算能力远远大于I/O,通信传输,还有数据库访问等操作。所以缓存出现了，从而提高了访问速度。但是由于会有多个缓存，以及数据读写问题，很有可能会读到脏数据，其实这也就是缓存的一致性。

另外为了提高效率，处理器会对程序进行乱序执行优化，而对于虚拟机来说，就是指令重排序。意思就是说代码顺序与实际执行顺序无关，实际执行顺序是虚拟机根据前后依赖关系，结合运算器来决定的，但是结果是一样的。

走入正题，先介绍一下java内存模型，内存模型主要用来屏蔽硬件与内存访问的差异。

对于每一个线程会有工作内存，多个线程共享一个主内存，例如对象实例就在主内存会多个线程共享，而引用这个对象的变量实际在每个线程的工作内存，工作内存拥有主内存实例的副本拷贝，通过它来对实例进行，读取与赋值都在工作内存，并且线程之间无法读取对方的变量，都是通过主内存做一个过渡作用。（这里工作内存与主内存跟堆内存与栈内存不是一个概念，这是为了好理解）

接下来工作内存与主内存怎么进行交互？虚拟机定义了8种原子操作,包括lock（锁定主内存的变量，使其被某一线程独占），unlock（同理），read（把一个主内存的变量传递到工作内存中，以便load），load（将从主内存传递的值传递到工作内存的变量副本中），store（将工作内存中变量副本传递到主内存中去，以便write），write（将工作内存传递过来的值赋到主内存中变量），use（将工作内存的值传递给执行引擎），assign（将执行引擎的值传递到工作内存），这8中操作可以用来确定你的访问是否安全。

下面介绍一下volatile，经常被问到的一个关键字，他的作用主要有两个，我们一一说明：1 保证变量在各个线程的可见性，意思就是说这个变量的值一修改，其他线程可以立即得知。而一个普通变量需要先写回主内存，然后其他线程去读取这个值。2：禁止指令重排序优化。然而它并不能保证原子性，以及运算的线程安全，下面代码来解释一下第一个特性。

我们希望结果会是10000，然而并不是，原因就是a++这一条指令并不是原子操作，volatile的确保证从主内存获得的数据是最正确的，但是当你运算的时候，其他线程很有可能会把一个值穿进去，导致值会变小。

那么什么情况下用volatile呢？一定要明白，它的开销一定会小与同步块。下面就是使用的情况，不符合这两条就要用同步块了。

1：运算结果并不依赖与当前值。

2：变量不需要与其他变量参与不变约束。

同样用代码解释一下。

个人理解就是a的值不依赖与现在在主内存a的实际值，不管a是几，都变成1，而其他线程也会立即受到通知，因为也没有运算，也会直接变为1.

接下来讲一下指令重排序优化的东东，其实指令重排序对于单线程来说有利无害，反正最后的结果是一样的，而且还提高了效率，但是对于多线程，可能会出现一些问题，而volatile修饰的变量，会在操作的时候，设置一个屏障，后面的操作，肯定不会比这个提前。否则后面的操作先执行，从而提前影响其他的线程。

好的，下面介绍几个概念1：原子性   就像前面说的那8张操作就是，粒度小到多线程也不可能拆开它，而用synchronized，内部的东西其实就是一个组装的“大原子”，但是记住volatile是不可以的 2 可见性 意思就是线程修改了值之后会立即同步到主内存，并且获取值会从主内存直接获取，而非缓存，volatile和synchronized都可以保证 3有序性 意思是保证线程内部执行顺序，volatile可以保证禁止指令重排序，而synchronized，直接就锁上了，所以它能解决几乎所有同步问题，造成了滥用。

线程是cpu调度的基本单位，粒度比进程小，Thread的类很多方法是native，可能会为了效率，然而同时可能会平台相关,注意线程的优先级不太靠谱，以为可能与平台线程的优先级不一样，造成冲突。再次补充一个线程状态模型（本文章主要介绍java多线程模型，以及volatile，线程基础不再赘述）

阻塞状态与挂起状态的区别在于阻塞在等待一个排它锁，而挂起是等待时间到，或者是唤醒。

更多细节请查看我的线程基础的这篇博客，多谢大家支持

本博客知识来源于深入理解java虚拟机，值得一看，强力 推荐，特别底层！！！

--------

12.Java中Volatile底层原理与应用

Volatile定义与原理

Java编程语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该通过排它锁单独获取这个变量

Java语言提供了Violatile来确保多处理开发中，共享变量的“可见性”，即当另外一个线程修改一个共享变量时，另外一个线程能读到这个修改的值。它是轻量级的synchronized，不会引起线程上下文的切换和调度，执行开销更小。

使用Violatile修饰的变量在汇编阶段，会多出一条lock前缀指令，它在多核处理器下回引发两件事情：

1. 将当前处理器缓存行的数据写回到系统内存
2. 这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效。

通常处理器和内存之间都有几级缓存来提高处理速度，处理器先将内存中的数据读取到内部缓存后再进行操作，但是对于缓存写会内存的时机则无法得知，因此在一个处理器里修改的变量值，不一定能及时写会缓存，这种变量修改对其他处理器变得“不可见”了。但是，使用Volatile修饰的变量，在写操作的时候，会强制将这个变量所在缓存行的数据写回到内存中，但即使写回到内存，其他处理器也有可能使用内部的缓存数据，从而导致变量不一致，所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现缓存一致性协议，每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期，如果过期，就会将该缓存行设置成无效状态，下次要使用就会重新从内存中读取。

追加字节优化Volatile性能

在某些情况下，通过将共享变量追加到64字节可以优化其使用性能。

在JDK 7 的并发包里，有一个队列集合类LinkedTransferQueue，它在使用volatile变量时，用一种追加字节的方式来优化队列出队和入队的性能。队里定义了两个共享结点，头结点和尾结点，都由使用了volatile的内部类定义，通过将两个共享结点的字节数增加到64字节来优化效率，具体分析如下：

部分CPU的L1、L2或L3缓存的高速缓存行64字节宽，不支持部分填充缓存行

这意味着，如果队列的头结点和尾结点都不足64字节，处理器会将他们读到同一个高速缓存行，在多处理器下每个处理器都会缓存同样的头尾结点，当一个处理器试图修改头结点时，会将整个缓存行锁定，那么在缓存一致性的机制下，其他处理器不能访问自己高速缓存中的尾节点，而头尾结点在队列中都是会频繁访问的，因此会影响使用性能。而通过填充字节使头尾结点加载到不同的缓存行，避免头尾结点在修改时相互锁定。 
但是在以下两种场景，不应该使用这种优化方式：

1. 缓存行非64字节宽的处理器（自行调整补充字节长度，原理一样）
2. 共享变量不会被频繁的写。追加字节会导致CPU读取性能下降，如果共享变量写的频率很低，那么被锁的几率也很小，就没必要避免相互锁定了

Volatile无法保证原子性

volatile是一种“轻量级的锁”，它能保证锁的可见性，但不能保证锁的原子性。 

public class Test {

    public volatile int inc = 0;

    public void increase() {

        inc++;

    }

    public static void main(String[] args) {

        final Test test = new Test();

        for(int i=0;i<10;i++){

            new Thread(){

                public void run() {

                    for(int j=0;j<1000;j++)

                        test.increase();

                };

            }.start();

        }

        while(Thread.activeCount()>1)  //保证前面的线程都执行完

            Thread.yield();

        System.out.println(test.inc);

    }

}

java -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly

Java HotSpot(TM) 64-Bit Server VM warning: PrintAssembly is enabled; turning on DebugNonSafepoints to gain additional output

Loaded disassembler from /Library/Java/JavaVirtualMachines/jdk1.8.0_101.jdk/Contents/Home/jre/lib/hsdis-amd64.dylib

Decoding compiled method 0x0000000110da4b50:

Code:

[Disassembling for mach='i386:x86-64']

[Entry Point]

[Constants]

  # {method} {0x000000010f163000} 'hashCode' '()I' in 'java/lang/String'

  #           [sp+0x40]  (sp of caller)

  0x0000000110da4cc0: mov    0x8(%rsi),%r10d

  0x0000000110da4cc4: shl    $0x3,%r10

  0x0000000110da4cc8: cmp    %rax,%r10

  0x0000000110da4ccb: jne    0x0000000110ceae20  ;   {runtime_call}

  0x0000000110da4cd1: data32 data32 nopw 0x0(%rax,%rax,1)

  0x0000000110da4cdc: data32 data32 xchg %ax,%ax

[Verified Entry Point]

  0x0000000110da4ce0: mov    %eax,-0x14000(%rsp)

  0x0000000110da4ce7: push   %rbp

  0x0000000110da4ce8: sub    $0x30,%rsp

  ......

最新文章

1. C#读取数据库中的表
2. asp.net web api集成微信服务（使用Senparc微信SDK）
3. 关于华擎X99+5820K
4. git学习笔记04-将本地仓库添加到GitHub远程仓库-git比svn先进的地方
5. LINQ.CS
6. opencv学习笔记（03）——遍历图像（迭代器法）
7. IOS上 关于状态栏的相关设置(UIStatusBar)
8. Java学习-练习1
9. HttpGet 请求
10. PhysicsBasedAnimation学习记录
11. Error: Can&#39;t find Python executable, you can set the PYTHON env variable.
12. Servlet（二）：初识Servlet
13. 二、认识Xcode（第一个工程：Hello world）
14. 查看windows上次开机时间
15. 在c++运行后出现PDB或者什么巴拉巴拉已经加载符号了的话
16. Python 进制转换与位运算
17. Spring3升级到Spring4时， 运行时出现找不到MappingJacksonHttpMessageConverter的情况
18. TransitiveClosure
19. testng的@Factory及其与@DataProvider的区别
20. ffmpeg命令

热门文章

1. js 前端 table 导出 excel
2. learning makefile VPATH
3. VMware与Centos系统安装、重置root密码
4. ln 链接命令 简要说明 软硬链接关系说明
5. 微信小程序des加密、PHP des解密
6. shell中获取时间
7. traceroute命令初探
8. FCC JS基础算法题(0):Reverse a String(翻转字符串)
9. nginx配置socket服务
10. easyui,文件引用