多线程基础学习八：volatile的使用

深碍√TFBOYSˉ_ 2022-06-06 10:05 163阅读 0赞

有一次去某个公司面试，面试官是两个人，他们问了我一个问题，是否知道【\[ˈvɒleɪt\] 】关键字，以及它的用法，我当时怎么都想不出来有这个关键字，只好说不知道，没见过这个关键字，面试没通过，临走的时候我让他们拼一下这个关键字，然后他们告诉我是【volatile】，现在想想都觉得是迷之读音啊。

### volatile ###

轻量级的同步机制，保证了数据的可见性，不保证原子性，网上资料都是这么说，然而我却不怎么理解。

### volatile ###

在上一篇学习中，我用synchronized实现一个简单额多线程计数的问题，现在尝试一下能否用volatile实现这个功能。  
测试代码：

public class VolitateTest { 
    
    
        public static void main (String[] args) {
    
            int i = 0;
            while (i < 10) {
                Thread thread = new VolitateThread();
                thread.start();
                i++;
            }
        }
    
    
        static class VolitateThread extends Thread { 
    
            @Override
            public void run () {
    
                Test.doSomething();
            }
        }
    
    
        static class Test { 
    
            public  static volatile   int num = 0;
            public   static void doSomething() {
                num++;
                System.out.println(num);
                SleepUtil.sleep(5000);// 模拟做事
            }
        }
    }

执行结果：

2
    4
    3
    3
    5
    6
    7
    8
    9
    10

执行了很多次，基本都是错误的数据结果。

我觉得，volatile的可见性保证了不同的线程读取的数据都是最新的（不知道底层怎么实现），但是不同线程可以都修改这个数据，不能保证数据的正确。  
所以我有点理解了为什么很多博主都说，volatile无法应用于计数。这样的话，单独使用volatile无法实现多线程的情况下的计数功能。

在以上理解的基础上，volatile适合修改线程和读取使用线程相互不影响的情况。

多个线程都要读取某个数据，但是不会修改这个数据；一个线程会修改数据。

测试代码：

public class VolitateTest { 
    
    
        public static void main (String[] args) {
    
            int i = 0;
            while (i < 10) {
                Thread thread = new VolitateThread();
                thread.start();
                i++;
            }
    
            Thread change = new ChangeThread();
            change.start();
        }
    
    
        static class VolitateThread extends Thread { 
    
            @Override
            public void run () {
                Test.doSomething();
            }
        }
    
        static class ChangeThread extends Thread { 
    
            @Override
            public void run () {
                Test.changeFlag();
            }
        }
    
    
        static class Test { 
    
            public  static volatile   boolean flag = true;
            public   static void doSomething() {
                if (flag) {
                    System.out.println("我在做事");
                    SleepUtil.sleep(5000);// 模拟做事
                }
            }
    
            public static  void changeFlag() {
                flag = false;
                SleepUtil.sleep(5000);
                System.out.println("状态改变了");
            }
        }
    }

输出结果：

我在做事
    我在做事
    我在做事
    我在做事
    我在做事
    我在做事
    状态改变了

10个做事线程，实际上只有6个做事了，剩下4个因为状态改变了，就没有做。

这是我想到最有可能的使用场景。但是我网上还有讲解更详细的，可以参考[这里][Link 1]

[Link 1]: http://blog.csdn.net/vking_wang/article/details/9982709