volatile

(1)保证线程可见性

---MESI（CPU缓存一致性协议）

注意：volatile在开发应用中没有把握则不用，尤其是修饰引用值（引用里边的对象成员变量改变是观察不到的），在修饰数量类型，比如int、long等等可以加。

代码示例：

/**
 * volatile 关键字，使一个变量在多个线程间可见
 * A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
 * 使用volatile关键字，会让所有线程都会读到变量的修改值
 * 
 * 在下面的代码中，running是存在于堆内存的t对象中
 * 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去
 * 读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行
 * 
 * 使用volatile，将会强制所有线程都去堆内存中读取running的值
 * 
 * 可以阅读这篇文章进行更深入的理解
 * http://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 */

public class T01_HelloVolatile {
   /*volatile*/ boolean running = true; //对比一下有无volatile的情况下，整个程序运行结果的区别
   void m() {
      System.out.println("m start");
      while(running) {
      }
      System.out.println("m end!");
   }
   
   public static void main(String[] args) {
      T01_HelloVolatile t = new T01_HelloVolatile();

//    jdk1.8 lambda表达式
//    new Thread(t::m, "t1").start();
      new Thread(
            new Runnable() {
               @Override
               public void run() {
                  t.m();

               }
            }
      ).start();

      try {
         TimeUnit.SECONDS.sleep(1);
      } catch (InterruptedException e) {
         e.printStackTrace();
      }
      
      t.running = false;
   }
   
}

（2）禁止指令重排序

咱们在新建变量的过程中第一申请内存，第二初始化，第三给变量赋值。这样在超高并发中可能会在第二步获取到第一步的默认值。

例子：双重检查单例给对象加volatile，禁止指令重排序。

代码示例：

public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }

    public static Mgr06 getInstance() {
        if (INSTANCE == null) {
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}

（2）不能保证原子性，所以不能代替synchronized

代码示例：

/**
 * volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
 * 运行下面的程序，并分析结果
 */

public class T04_VolatileNotSync {
   volatile int count = 0;
   void m() {
      for(int i=0; i<10000; i++) count++;
   }
   
   public static void main(String[] args) {
      T04_VolatileNotSync t = new T04_VolatileNotSync();
      
      List<Thread> threads = new ArrayList<Thread>();
      
      for(int i=0; i<10; i++) {
         threads.add(new Thread(t::m, "thread-"+i));
      }
      
      threads.forEach((o)->o.start());
      
      threads.forEach((o)->{
         try {
            o.join();
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      });
      
      System.out.println(t.count);
      
      
   }
   
}

代码示例：

/**
 * 对比上一个程序，可以用synchronized解决，synchronized可以保证可见性和原子性，volatile只能保证可见性
 */

public class T05_VolatileVsSync {
   /*volatile*/ int count = 0;

   synchronized void m() { 
      for (int i = 0; i < 10000; i++)
         count++;
   }

   public static void main(String[] args) {
      T05_VolatileVsSync t = new T05_VolatileVsSync();

      List<Thread> threads = new ArrayList<Thread>();

      for (int i = 0; i < 10; i++) {
         threads.add(new Thread(t::m, "thread-" + i));
      }

      threads.forEach((o) -> o.start());

      threads.forEach((o) -> {
         try {
            o.join();
         } catch (InterruptedException e) {
            e.printStackTrace();
         }
      });

      System.out.println(t.count);

   }

}