多线程中volatile的理解和static的区别

最新推荐文章于 2025-04-21 22:16:00 发布

huopusa

最新推荐文章于 2025-04-21 22:16:00 发布

阅读量5.8k

点赞数 3

分类专栏：多线程文章标签： volatile 并发多线程

本文链接：https://blog.youkuaiyun.com/weixin_39076716/article/details/80675998

版权

多线程专栏收录该内容

4 篇文章

订阅专栏

1.多线程访问同一个可变变量，需增加同步机制

说明：根据Java Language Specification中对Java内存模型的定义, JVM中存在一个主内存(Java Heap Memory)，Java中所有变量都储存在主存中，对于所有线程都是共享的。每个线程都有自己的工作内存(Working Memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。根据上述内存模型的定义，要在多个线程间安全的同步共享数据就必须使用锁机制，将某线程中更新的数据从其工作内存中刷新至主内存，并确保其他线程从主内存获取此数据更新后的值再使用
这里写图片描述

2.示例：
错误示例：下面的代码中，没有对可变数据stopRequested的访问做同步。程序期望在一秒钟后线程能停止。但在用java 1.6的server模式运行此程序（Java –server StopThread）时，程序陷入死循环，不能结束。

public class StopThread {
    private static boolean is_running = false;
    public static void main(String[] args) throws InterruptedException {
        Thread backgroundThread = new Thread(new Runnable() {
            public void run() {
                int i = 0;
                while (!is_running){
                    i++;
                }
            }
        });
        backgroundThread.start();
        TimeUnit.SECONDS.sleep(1);
        stopRequested = true;
    }
}

这里为什么会陷入死循环,永远不会停止呢?
参照：深入理解Java虚拟机_JVM高级特性与最佳实践 12.3.3节
JIT或HotSpot编译器在server模式和client模式编译不同，server模式为了使线程运行更快，如果其中一个线程更改了变量boolean flag 的值，那么另外一个线程会看不到，因为另外一个线程为了使得运行更快所以从寄存器或者本地cache中取值，而不是从内存中取值，那么使用volatile后，就告诉不论是什么线程，被volatile修饰的变量都要从内存中取值。
java在server模式下,各个线程使用各自的工作内存,一个线程改变了变量的值,另外一个线程并不会从主存中取
解决方案：
增加了 synchronized同步机制后，程序就能正确地在 1秒后终止。

public class StopThread {
    private static boolean stopRequested;
    private static synchronized void requestStop() {
        stopRequested = true;
    }
    private static synchronized boolean isStopRequested() {
        return stopRequested;
    }
    public static void main(String[] args) throws InterruptedException {
        Thread backgroundThread = new Thread(new Runnable() {
            public void run() {
                int i = 0;
                while (!isStopRequested()) {
                    i++;
                }
            }
        });
        backgroundThread.start();
        TimeUnit.SECONDS.sleep(1);
        requestStop();
    }
}

另一个方案是在变量前增加 volatile
private static volatile boolean is_running = false;

二. static和volatile的区别

参考http://blog.sina.com.cn/s/blog_4e1e357d0101i486.html
1. volatile是告诉编译器,每次取这个变量的值都需要从主存中取,而不是用自己线程工作内存中的缓存.
2. static 是说这个变量,在主存中所有此类的实例用的是同一份,各个线程创建时需要从主存同一个位置拷贝到自己工作内存中去(而不是拷贝此类不同实例中的这个变量的值),也就是说只能保证线程创建时,变量的值是相同来源的,运行时还是使用各自工作内存中的值,依然会有不同步的问题.

三、延伸 volatile

虽然volatile是在运行时取值但是并不能保证并发的绝对安全
示例：

/**
 * volatile 变量自增运算测试
 */
public class VolatileTest {

    public static volatile int race = 0;

    public static void increase(){
        race++;
    }
    //规定开启的线程数量
    private static final int THREADS_COUNT = 20;

    public static void main(String[] args){
        Thread[] threads =  new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        // 等待所有累加线程都结束
        while (Thread.activeCount()>1){
            Thread.yield();
        }
        System.out.println(race);
    }
}