java 内存模型与volatile关键字

Posted 2021-02-14

java内存模型可以大致理解分为两个模块，主内存和私有内存。主内存中主要是存放一些共享的全局变量，私有内存主要是存放线程所需的私有变量。一般情况下，如果某个线程需要使用主内存的全局变量。首先，它会拷贝一份主内存里面的全局变量到私有内存，进行操作，操作完成以后再把这个变量同步到主内存。如下图：

如果是单线程的，到没什么问题，但是如果是多线程的，就有可能出现数据不一致的问题，因为线程之间是不可见的。看下面一个例子：

package org.hzg.volatilekeyword;
/**
 * Created by hzgal on 2019-3-21.
 */
class ThreadVolatileDemo extends Thread {
    public boolean flag = true;
    @Override
    public void run() {
        System.out.println("ThreadVolatileDemo线程开始执行....");
        while (flag) {
        }
        System.out.println("ThreadVolatileDemo线程停止");
    }
    public void stopThread() {
        this.flag = false;
    }
}

public class Demo1 {
    public static void main(String[] args) throws InterruptedException {
        ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo();
        threadVolatileDemo.start();
        Thread.sleep(3000);
        threadVolatileDemo.stopThread();
        System.out.println("flag 已经设置成false");
        Thread.sleep(1000);
        System.out.println(threadVolatileDemo.flag);
    }
}

上面这段程序执行后会发生一个现象，就是会一直执行。原因就在于主线程中虽然对flag进行了修改，但是线程挂起了一秒，导致在主线程私有内存里面的flag没有同步到主内存中，所以子线程的flag仍然为true，导致自线程一直在执行。解决方案，利用volatile关键字，volatile关键字有如下含义：
1）保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
2）禁止进行指令重排序。
也就是说在并发编程中，volatile关键字可以在一定程度上保证可见性和有序性。上面的问题这样处理就可以了。

public volatile boolean flag = true;

但是问题来了，使用volatile有一个弊端，就是它无法保证并发编程下的一致性。看下面这个例子：

package org.hzg.volatilekeyword;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by hzgal on 2019-3-22.
 */
class VolatileDemo2 extends Thread{
    private volatile static int count;
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            count++;
        }
        System.out.println("线程" + currentThread().getName() + "执行结束，结果为：" + count);
    }
}
public class Demo2 {
    public static void main(String[] args) {
        List<VolatileDemo2> thradList = new ArrayList<VolatileDemo2>(10);
        for (int i = 0; i < 10; i++) {
            thradList.add(new VolatileDemo2());
        }
        for (VolatileDemo2 volatileDemo2 : thradList) {
            volatileDemo2.start();
        }
    }
}

上面的例子会出现如下情况：

这就是volatile关键字虽然使得每个线程都对count可见，但是无法保证这些线程对count的操作是原子的。有可能两个线程同时执行了count++的操作，但是只有一次同步到主内存了。解决上面的问题的方法有很多，其核心的思想就是加锁，保证对count变量的操作的原子性即可。下面举两个例子：
1、利用java并发包里面的工具类。如下：

package org.hzg.volatilekeyword;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
 * Created by hzgal on 2019-3-22.
 */
class VolatileDemo3 extends Thread{
    private volatile static AtomicInteger count = new AtomicInteger(0);
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            count.incrementAndGet();
        }
        System.out.println("线程" + currentThread().getName() + "执行结束，结果为：" + count.get());
    }
}
public class Demo3 {
    public static void main(String[] args) {
        List<VolatileDemo3> thradList = new ArrayList<VolatileDemo3>(10);
        for (int i = 0; i < 10; i++) {
            thradList.add(new VolatileDemo3());
        }
        for (VolatileDemo3 volatileDemo3 : thradList) {
            volatileDemo3.start();
        }
    }
}

结果如下：

2、利用synchronized关键字

package org.hzg.volatilekeyword;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by hzgal on 2019-3-22.
 */
class VolatileDemo4 extends Thread{
    private volatile static int count;
    private static final String lock = "countLock";
    @Override
    public void run() {
        synchronized (lock) {
            for (int i = 0; i < 1000; i++) {
                count++;
            }
            System.out.println("线程" + currentThread().getName() + "执行结束，结果为：" + count);
        }
    }
}
public class Demo4 {
    public static void main(String[] args) {
        List<VolatileDemo4> thradList = new ArrayList<VolatileDemo4>(10);
        for (int i = 0; i < 10; i++) {
            thradList.add(new VolatileDemo4());
        }
        for (VolatileDemo4 volatileDemo4 : thradList) {
            volatileDemo4.start();
        }
    }
}

结果如下：