java并发之volatile变量

介绍

       在java并发编程中，volatile变量占据了重要地位，与synchronized一样，都是java并发编程的重要组成部分，与synchronized不同的是，它只可以修饰变量， volatile可以看做轻量级的synchronized，即轻量级的锁

认识volatile

   ①如果某个变量被volatile修饰的话，在多线程模式的情景下，访问该变量，都能保证读取到该值的最新值（如果有多个线程对该值修改的情况下，保证能读到最后一个线程对其修改后的值），也就是大家常说的volatile能保证“可见性”

   ②对任意单个volatile变量的读/写具有原子性，但对于复合方法则不保证原则性

volatile的内存模型

（图片来自于java并发网）

在JMM模型中，多线程编程中，为了提高线程的处理速度，每个线程不会直接和内存直接交互（这边应该指的是java的堆区），而是将其缓存一份到自己的本地栈区，经过自己的业务逻辑操作，再写回到主内存区，这样就会产生所谓的“脏读”，例如A线程，将上图的变量a进行修改，修改成a = 2，但此时并没有立即写回主内存区，线程B读取的时候依旧读取的a = 1,线程的不安全就是这么产生的

如果用volatile关键字修饰a变量，JVM则会将本地缓存的变量写回到内存，且其他对该值的缓存的线程会主动去内存中拉取a值的最新值，观察自己的缓存是否失效（换句话说，其实可以理解成没有了缓存，任何线程直接去主内存读取）

volatile线程安全吗？我们测试一下

package com.lyncc.bazinga.study.thread.volatilekey;



public class TestVolatile {
    
    public static void main(String[] args) {
            MyThread myThread = new MyThread();
            for(int j = 0;j<10000;j++){
                Thread thread = new Thread(myThread);
                thread.start();
            }
    }
}

class MyThread implements Runnable {
    
    private volatile int i = 1;
    
    
    public void run() {
        try {
            Thread.sleep(1l);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        getAndIncrement();
        System.out.println(i);
    }

    public void getAndIncrement () {
       int j = get();
       j++;
       set(j);
    }
    
    public void set(int l) {
        i = l;   
    }
    
    public int get() {
        return i;
    }
    
}

我们创建10000个线程，同时对volatile变量进行自加操作，如果线程安全，i的值经过10000次的自增，最后的值应该是10001,但测试结果

最后的值是9881，并不是我们期待的10001，那么问题出在哪里呢，因为我们知道volatile修饰的变量读取和写入都是原子性的，也就说上述的get方法和set()方法是线程安全的，唯一的问题就是出在j++上面了，其实可以理解，加入线程A,B同时都读取主内存的变量，假如此时A,B线程中的i = 3001,A线程稍微快点，进行+1操作，写写回内存，但B线程读取的时候，A线程还没有写回，所以B写回的值依旧是3002,导致i少加一次，所以这不能怪volatile不行，只能怪i++不是原子性的，我们可以放大这个漏洞，修改一下代码，在j++之前睡1毫秒

package com.lyncc.bazinga.study.thread.volatilekey;



public class TestVolatile {
    
    public static void main(String[] args) {
            MyThread myThread = new MyThread();
            for(int j = 0;j<10000;j++){
                Thread thread = new Thread(myThread);
                thread.start();
            }
    }
}

class MyThread implements Runnable {
    
    private volatile int i = 1;
    
    
    public void run() {
        getAndIncrement();
        System.out.println(i);
    }

    public void getAndIncrement () {
       int j = get();
       try {
           Thread.sleep(1l);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       j++;
       set(j);
    }
    
    public void set(int l) {
        i = l;   
    }
    
    public int get() {
        return i;
    }
    
}

运行结果

你会发现写回来的值重复性更好，因为我们在get之后睡了1毫秒，此时可能会聚集很多线程get了同一i的最新值，然后都沉睡一毫米，然后同时唤醒，进行+1操作，所以值就会一样了，且远远小于10001了

volatile的用途

如果volatile是线程不安全的，那么问题来了，要它何用，直接用synchronized就可以了，其实不对，synchronized有上下文的切换，而volatile没有，所以减少了上下文切换的时候，其次，我们在多线程编程的时候，最最重要的就是保证线程安全的前提下，降低锁的竞争，去优化锁，尽量锁住最细力度，如上面例子而言，问题出在j++上面，如果我们搞定了j++的并发问题，是不是就可以保证线程安全，我们可以这样实现在getAndIncrement的方法上加synchronized这样的确能做到，但性能却不怎么样，因为get和set本身就是线程安全的（volatile的功劳），如果我们j++线程安全的，就一切搞定了，怎么搞定可以参考java.util.concurrent.atomic.AtomicInteger的源码

参考文档

http://ifeve.com/volatile/

http://www.open-open.com/lib/view/open1459412319988.html