Java进阶：volatile使用详解

小咪咪 2022-12-23 01:58 134阅读 0赞

# **概述** #

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center]

# **可见性验证** #

如下一段代码，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循环，不会输出最后一条“执行完毕”

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 1]

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

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 2]

# **原子性验证** #

看下面一段代码，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，但是这边执行后，结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 3]

# **原子性问题解决** #

> 方法一：使用 synchronized 关键字

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

结果如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 4]

> 方法二：使用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，这里就不再贴图了

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/d4cb72cdd58e4f2aafccbd3a775a2209.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/c5b695f431e04ffabaf9dbcd9ba792c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200916164300227.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200916171706121.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/2020091617204337.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI4ODM0MzU1,size_16,color_FFFFFF,t_70#pic_center