本文共 2512 字，大约阅读时间需要 8 分钟。

volatile关键字是Java中提供的另一种解决可见性和有序性问题的方案。

对volatile变量的单次读/写操作可以保证原子性的。

但是并不能保证i++这种操作的原子性，因为本质上i++是读、写两次操作。 在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制

当且仅当满足以下所有条件时，才应该使用volatile变量：

对变量的写操作不依赖变量的当前值，或者你能确保只有单个线程更新变量的值。

该变量不会与其他变量一起纳入不变性条件中。 在访问变量时不需要加锁。

volatile 关键字，使一个变量在多个线程间可见

A B线程都用到一个变量，java默认使A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道 可以通过下图来表示线程的存储：

使用volatile关键字，会让所有线程都会读到变量的修改值

volatile 并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能代替synchonized

public class T6 {
       /*volatile*/ boolean running = true;    public void m()    {
           System.out.println("start");        while(running)        {
               //加入sleep 可能抽出时间来更新缓冲区中的值//            try {
   //                Thread.sleep(1000);//            } catch (InterruptedException e) {
   //                e.printStackTrace();//            }        }        System.out.println("end");    }    public static void main(String[] args) {
           T6 t6 = new T6();        new Thread(()->t6.m()).start();        try {
               Thread.sleep(2000);        } catch (InterruptedException e) {
               e.printStackTrace();        }        t6.running = false;    }}

程序运行结果：

可以看到线程1陷入了死循环，也就是说线程1并没有收到主线程更新running值的操作，这是因为线程1一直在执行while循环，虽然主线程向内存写入了running的值，但是线程1没有时间去读内存中running的值，所以会一直陷入死循环。 当在源程序的基础上在while循环中加入睡眠1秒钟时的运行结果： 可以看到因为睡眠了1秒钟，线程1趁机去内存中更新了running的值。 在源程序的基础上在running上添加volatile关键字的运行结果： 由于加上了volatile关键字，使得主线程更新running值的同时，线程1会收到通知，去更新自己缓冲区中running变量的值，于是while循环就退出了。 volatile 并不能保证多个线程共同修改running变量时所带来的不一致问题,也就是说volatile不能代替synchonized。

synchnized 既可以保障原子性和可见性，volatile只能保障可见性

public class T7 {
       volatile int count = 0;    /*synchronized*/ void m()    {
           for (int i=0;i<10000;i++) count++;    }    public static void main(String[] args) {
           T7 t7 = new T7();        List
   
     threadList= new ArrayList();        for (int i=0;i<10;i++)        {
               threadList.add(new Thread(()->t7.m(),"thread"+i));        }        //启动线程        threadList.forEach((o)->o.start());        //等待线程结束        threadList.forEach((o)->{
               try {
                   o.join();            } catch (InterruptedException e) {
                   e.printStackTrace();            }        });        System.out.println(t7.count);    }}
   

程序运行结果：

可以看到count的值比正确值100000差了很多，因为是多个线程同时执行count++操作，并且count++操作是一个读->写的过程，多个线程同时进行读->写的操作就会出现加的值少的问题。 给m方法加上synchronized关键字后的运行结果: 因为给方法加了锁，所以使线程线性执行，所以不会出现问题。 解决同样问题的更高效的方法是使用AtomXXXX类

AtomXXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的。

转载地址：http://gdaen.baihongyu.com/