Java进阶：volatile使用详解

概述

volatile是Java提供的轻量级的同步机制，保证了可见性，不保证原子性。
了解volatile工作机制，首先要对Java内存模型（JMM）有初步的认识：

• 每个线程创建时，JVM会为其创建一份私有的工作内存（栈空间），不同线程的工作内存之间不能直接互相访问
• JMM规定所有的变量都存在主内存，主内存是共享内存区域，所有线程都可以访问
• 线程对变量进行读写，会从主内存拷贝一份副本到自己的工作内存，操作完毕后刷新到主内存。所以，线程间的通信要通过主内存来实现。
• volatile的作用是：线程对副本变量进行修改后，其他线程能够立刻同步刷新最新的数值。这个就是可见性。

可见性验证

如下一段代码，number字段没有用volatile修饰。

• 创建一个子线程
• 子线程sleep 3s（目的是让主线程先加载number=0的变量）
• 子线程把number改成100。
• 这时主线程的number仍然为0，不会同步成100

public class 可见性 {
    static class MyTest {
        public int number = 0;
        public void changeNumber(){
            number = 100;
        }
    }
    public static void main(String[] args) throws InterruptedException{
        MyTest myTest = new MyTest();

        new Thread(() -> {
            System.out.println(String.format("线程%s开始执行", Thread.currentThread().getName()));

            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            myTest.changeNumber();
            System.out.println(String.format("线程%s的number：%d", Thread.currentThread().getName(), myTest.number));
        }, "NewThread").start();

        while (myTest.number == 0){

        }

        System.out.println("执行完毕");
    }
}

执行结果如下，一直卡在while循环，不会输出最后一条“执行完毕”

还是上面的代码，给number变量加上volatile关键字

    static class MyTest {
        public volatile int number = 0;
        public void changeNumber(){
            number = 100;
        }
    }

重新执行一下，结果变了，主线程能够及时同步number值的变动

原子性验证

看下面一段代码，number变量加了volatile修饰。创建了10个子线程，每个线程循环1000次执行number++。

public class 原子性1
{
    static class MyTest {
        public volatile int number = 0;
        public void incr(){
            number++;
        }
    }

    public static void main(String[] args) {
        MyTest myTest = new MyTest();
        for (int i = 1; i <= 10; i++){
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++){
                    myTest.incr();
                }
            }, "Thread"+String.valueOf(i)).start();
        }

        //等线程执行结束了，输出number值
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println("当前number：" + myTest.number);
    }
}

按理说number最终应该是10000，但是这边执行后，结果如下：

原子性问题解决

方法一：使用 synchronized 关键字

//给函数增加synchronized修饰，相当于加锁了
public synchronized void incr(){
    number++;
}

结果如下：

方法二：使用AtomicInteger

public class 原子性2
{
    static class MyTest {
        public volatile AtomicInteger number = new AtomicInteger();
        public void incr(){
            number.getAndIncrement();
        }
    }

    public static void main(String[] args) {
        MyTest myTest = new MyTest();
        for (int i = 1; i <= 10; i++){
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++){
                    myTest.incr();
                }
            }, "Thread"+String.valueOf(i)).start();
        }

        //等线程执行结束了，输出number值
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println("当前number：" + myTest.number);
    }
}

输出结果一样是10000，这里就不再贴图了