volatile关键字的用法

volatile 关键字的概念

volatile 概念：volatile 关键字的主要作用是使变量在多个线程间可见。

public class VolatileDemo extends Thread {

    private volatile boolean isRunning = true;

    private void setRunning(boolean isRunning) {
        this.isRunning = isRunning;
    }

    @Override
    public void run() {
        System.out.println("进入run方法..");
        int i = 0;
        while (isRunning) {
            //...
        }
        System.out.println("线程停止");
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileDemo vd = new VolatileDemo();
        vd.start();
        TimeUnit.SECONDS.sleep(2);
        vd.setRunning(false);
        System.out.println("isRunning的值已经被设置了false");
    }

}

例子总结：
如下图所示：在 Java 中，每一个线程都会有一块工作内存区，其中存放着所有线程共享的主内存中的变量值的拷贝。当线程执行时，他在自己的工作内存区中操作这些变量。为了存取一个共享的变量，线程通常先获取锁定并去清除它的内存工作区，把这些共享变量从所有线程的共享内存区中正确的装入到他自己所在的工作内存区中，当线程解锁时保证该工作内存区中变 量的值写回到共享内存中。 一个线程可以执行的操作有使用（use）、赋值（assign）、装载（load）、存储（store）、 锁定（lock）、解锁（unlock).。
而主内存可以执行的操作有读（read）、写（write）、锁定（lock）、解锁（unlock) 每个操作都是原子的。
volatile 的作用就是强制线程到主内存（共享内存）里去读取变量，而不去线程工作内存区里去读取，从而实现了多个线程间的变量可见。也就是满足线程安全的可见性。

volatile 关键字的非原子性

volatile-关键字虽然拥有多个线程之间的可见性，但是却不具备同步性（也就是原子性），可以算上是一个轻量级的 synchronized，性能要比 synchronized 强很多，不会造成阻塞（在很多开源的架构里，比如 netty 的底层代码就大量使用 volatile）这里需要注意：一般 volatile 用于只针对于多个线程可见的变量操作，并不能代替 synchronized 的同步功能，示例代码如下：

/**
 * volatile关键字不具备synchronized关键字的原子性（同步）
 */
public class VolatileNoAtomic extends Thread {

     private static volatile int count;
    //private static AtomicInteger count = new AtomicInteger(0);

    private static void addCount() {
        for (int i = 0; i < 1000; i++) {
             count++;
           // count.incrementAndGet();
        }
        System.out.println(count);// 10000
    }

    public void run() {
        addCount();
    }

    public static void main(String[] args) {
        VolatileNoAtomic[] arr = new VolatileNoAtomic[10];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new VolatileNoAtomic();
        }

        for (int i = 0; i < 10; i++) {
            arr[i].start();
        }
    }

}

示例总结： volatile 关键字只具有可见性，没有原子性。要实现原子性建议使用 atomic 类的系列对象，支持原子性操作（注意 Atomica 类只保证本身方法原子性，并不保证多次操作的原子性）示例如下：

public class AtomicUse {

    private static AtomicInteger count = new AtomicInteger(0);

    /*
        多个 addAndGet 在一个方法内是非原子性的，
        需要加 synchronized 进行修饰，保证 4 个 addAndGet 整体原子性
     */
    public synchronized int multiAdd() {
        try {
            TimeUnit.MILLISECONDS.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        count.addAndGet(1);
        count.addAndGet(2);
        count.addAndGet(3);
        count.addAndGet(4); // +10
        return count.get();
    }

    public static void main(String[] args) throws InterruptedException {
        final AtomicUse au = new AtomicUse();

        List<Thread> ts = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            ts.add(new Thread(() -> System.out.println(au.multiAdd())));
        }

        for (Thread t : ts) {
            t.start();
        }

        TimeUnit.SECONDS.sleep(2);
        System.out.println("count = " + count);// 1000
    }

}