Java 并发 volatile学习笔记

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<Thread> 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类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的。