java并发特性，原子性、有序性、可见性

1. 原子性是指一个操作是不可中断的。即使是在多个线程一起执行的时候，一个操作一旦开始，就不会被其它线程干扰。

   Java中的原子操作包括：

   1）除long和double之外的基本类型的赋值操作

   2）所有引用reference的赋值操作
   3）java.concurrent.Atomic.* 包中所有类的一切操作。
   但是java对long和double的赋值操作是非原子操作！！long和double占用的字节数都是8，也就是64bits。在32位操作系统上对64位的数据的读写要分两步完成，每一步取32位数据。这样对double和long的赋值操作就会有问题：如果有两个线程同时写一个变量内存，一个进程写低32位，而另一个写高32位，这样将导致获取的64位数据是失效的数据。因此需要使用volatile关键字来防止此类现象。volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的。

   public class UnatomicLong implements Runnable {
       private static long test = 0;
   
       private final long val;
   
       public UnatomicLong(long val) {
           this.val = val;
       }
   
       @Override
       public void run() {
           while (!Thread.interrupted()) {
               test = val; //两个线程都试图将自己的私有变量val赋值给类私有静态变量test
           }
       }
   
       public static void main(String[] args) {
           Thread t1 = new Thread(new UnatomicLong(-1));
           Thread t2 = new Thread(new UnatomicLong(0));
   
           System.out.println(Long.toBinaryString(-1));
           System.out.println(pad(Long.toBinaryString(0), 64));
   
           t1.start();
           t2.start();
   
           long val;
           while ((val = test) == -1 || val == 0) { 
          //如果静态成员test的值是-1或0，说明两个线程操作没有交叉
           }
   
           System.out.println(pad(Long.toBinaryString(val), 64));
           System.out.println(val);
   
           t1.interrupt();
           t2.interrupt();
       }
   
       // prepend 0s to the string to make it the target length
       private static String pad(String s, int targetLength) {
           int n = targetLength - s.length();
           for (int x = 0; x < n; x++) {
               s = "0" + s;
           }
           return s;
       }
   }

    运行发现程序在while循环时进入了死循环，这是因为使用的JVM是64bits。在64位JVM中double和long的赋值操作是原子操作。
   在eclipse中修改jre为一个32bit的JVM地址，则会有如下运行结果：
   1111111111111111111111111111111111111111111111111111111111111111
   0000000000000000000000000000000000000000000000000000000000000000
   0000000000000000000000000000000011111111111111111111111111111111 
   //很明显test的值被破坏了
   4294967295

    

2. 有序性

   有序性即程序执行的顺序按照代码的先后顺序执行。

         在Java内存模型中，允许编译器和处理器对指令进行重排序，但是重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。（例如：重排的时候某些赋值会被提前）
   在Java里面，可以通过volatile关键字来保证一定的“有序性”（具体原理在下一节讲述）。另外可以通过synchronized和Lock来保证有序性，很显然，synchronized和Lock保证每个时刻是有一个线程执行同步代码，相当于是让线程顺序执行同步代码，自然就保证了有序性

    

3. 可见性 

    可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

   
   

   可见性，Java提供了volatile关键字来保证可见性。

   当一个共享变量被volatile修饰时，它会保证修改的值会立即被更新到主存，当有其他线程需要读取时，它会去内存中读取新值。
   而普通的共享变量不能保证可见性，因为普通共享变量被修改之后，什么时候被写入主存是不确定的，当其他线程去读取时，此时内存中可能还是原来的旧值，因此无法保证可见性。
   另外，通过synchronized和Lock也能够保证可见性，synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码，并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。