atomicity and volatility 代替synchronized 对象锁 的另一种方法（原子操作+可见性）

参考文章：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#volatile

               https://www.ibm.com/developerworks/library/j-jtp06197/index.html

               https://tutorials.jenkov.com/java-concurrency/volatile.html

1、atomicity(原子操作):一个操作不中断，一直执行完

                              对成员变量进行操作。

    volatile:就是在原子操作下，保证变量的visible。

2、按照：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#volatile

  编译和运行时:

    1>禁止分配它们到寄存器（registers），保证一个线程写后能马上更新到内存，所有线程都能看见，

    2>必须保证volatile变量读之前缓冲区（cpu cache）无效，哪么线程只能在内存读。

class VolatileExample {  int x = 0;  volatile boolean v = false;  public void writer() {    x = 42;    v = true;  }  public void reader() {    if (v == true) {      //uses x - guaranteed to see 42.    }  }}

     1>如果v不是volatile变量，哪么reader()读操作，当v==true，有可能读到x=0。

         原因：有可能编译器重新排序 v=true,x=42,哪么读出的是未改变的值。

          所以：编译器看见有volatile变量存在的地方，有cpu缓存，但是读时不让去缓冲读，直接从内存读，不重新排序。

一、功能介绍

1、atomicity ：原子操作，也叫lock-free 无锁，即不需要锁操作。

    优点：操作不能被thread 调度者中断，一气呵成，比如：正在高考数学，考完才出来吧！

   atomicity :对应单cpu ,在多cpu用 visibility代替。

2、比较

synchronized：不能保证共享变量前的所有变量数据（非共享数据）一定会存入内存。
   如果是共享数据，哪么感觉两个线程基本上会看见新值。
因为这syn对象锁保证只有单独一个线程读数据后，保存到内存，下一个线程才能读，这是syn对象锁的基本功能。atomicity，volatile：
  编译器或jvm不能重新排序volatil 指令的执行顺序。  特殊情况有可能如下：
一个synchronized 线程改变成员变量值后
  1》首先应该写入到缓冲中，如果当前干活线程改变值后，值存放在缓中，未向内存写。
  2》这时手动删除本window7的缓存，
 3》下一个线程执行的话，去内存取，还是以前的值,所以刚刚改的值根本未入内存
  感觉只有这种情况下才会出错，一般应该没问题。1>一个线程写入变量后，马上入内存。
2>多个线程读，直接去内存读，所以这种情况数据不存在一致性问题。
但是，如果一个线程写入变量到cache后，未入内存，刚好另一个线程从内存读，又出现一致性问题了。

  目前默认原子操作的变量：primtive types(int,char,byte):原子操作，读、写只需要一条指令即可。

                   1》返回值 return i;这是一个原子操作。          

3、  volatility：对syn对象锁的补充。

      a long or double:是64位，一次读，非原子操作,需要分成两个32位来操作，对应两条指令，两条指令中间可以插入其它指令。        

   （1） 设置成员变量：非volatility 

           当对一个线程对成员变量进行的an atomic 操作时，就我一个干活线程用，别的干活线程不用，哪么也不需要刷新main memory了（主要目的让别的线程看见新改的值）

  （2）设置成员变量：volatility （有波动的意思）

         1>实时更新数据

            多个干活线程访问同一个成员变量时，必须设置成volatility ，当一个线程改了成员变量值，哪么所有用到这个成员变量的干活线程必须能看见新改的值。

         2>volatility  可以让一个long 变量成为原子操作?未测试

           本来一个64位的 long是非原子操作。

二、例子：  一看，感觉下面两个方法对成员变量i是原子操作 

                   但是指令“get” 和 "put" 之间，另一个对象也可以修改成员变量的值，所以下面操作非原子。

          Atomicity 类，可以new Atomicity（），生成多个对象，并且多个对象都可以操作f1(),f2()方法，有可能存在先执行，同时执行等待的可能。

package concurrency;
public class Atomicity {                   
int i;
void f1() {
i++;
}
void f2() {
i += 3;
}
}反编译：
  void f1();
  Code:
0: aload_0
1: dup
2: getfield #2; //取得成员变量i
5: iconst_1
6: iadd
7: putfield #2; //保存成员变量i
10: return
void f2();
Code:
0: aload_0
1: dup
2: getfield #2; //Field i:I
5: iconst_3
6: iadd
7: putfield #2; //Field i:I
10: return

三、不要盲目使用原子的思想

   下面例子本想取一个偶数值，但是由于getValue 以为是原子操作，没有设置对象锁。

     因此当evenIncrement 执行到一个i++后（奇数）------getValue 取值，出现错误。

     1、成员变量 i

      2、方法getValue（只有返回值），是一个原子操作

      3、方法 evenIncrement 带有对象锁  自增1，两次，

      4、干活线程AtomicityTest，

     

package concurrency;
import java.util.concurrent.*;
public class AtomicityTest implements Runnable {
private int i = 0;
public  int  getValue() {
return i;
}
private synchronized void evenIncrement() {
i++;
i++;
}
public void run() {
System.out.println("run 开始!");
while (true)
evenIncrement();
}
public static void main(String[] args) {
ExecutorService exec = Executors.newCachedThreadPool();
AtomicityTest at = new AtomicityTest();
exec.execute(at);
System.out.println("main!");
while (true) {
System.out.println("main 循环开始!");
int val = at.getValue();
System.out.println("val ="+val);
if (val % 2 != 0) {
System.out.println(val);
System.exit(0);
}
}
}
}

参考文章：http://www.cs.umd.edu/~pugh/java/memoryModel/jsr-133-faq.html#volatile