volatile关键字与内存可见性

╰半夏微凉° 2023-02-18 09:44 19阅读 0赞

### 一、volatile关键字与内存可见性 ###

**1、测试没有 volatile关键字的demo**

public class VolatileTest1 {
    
        public static void main(String[] args) {
            ThreadDemo threadDemo = new ThreadDemo();
            new Thread(threadDemo).start();
            while(true){
                if(threadDemo.isFlag()){
                    System.out.println("----主线程读到flag为true----");
                    break;
                }
            }
        }
    }
    
    class ThreadDemo implements Runnable {
        private boolean flag = false;
        @Override
        public void run() {
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
            }
            flag = true;
            System.out.println("子线程修改了值flag=" + isFlag());
        }
        public boolean isFlag() {
            return flag;
        }
        public void setFlag(boolean flag) {
            this.flag = flag;
        }
    }

![20200617101509854.png][]

在子线程中将线程的共享变量 flag的值修改成了 true时，但是主线程在条件判断时读到的flag一直是false，所以while循环不会停止跳出，程序不会终止。这是由于内存的可见性导致的。

**2、内存可见性（Memory Visibility）**

内存可见性（Memory Visibility）其实是指共享变量在不同线程之间的可见性。

*  共享变量：如果一个变量在多个线程的工作内存中都存在副本，那么这个变量就是这几个线程的共享变量，即通常称这种被多个线程访问的变量为共享变量。
 *  可见性：指当某个线程正在使用共享变量并对共享变量的值做了修改时，能够及时的被其他线程看到共享变量的变化。

内存可见性与Java内存模型有关系

所有的变量都存储在主内存中（操作系统给进程分配的内存空间），而每个线程都有自己独立的工作内存，里面保存该线程使用到的变量的副本。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70][]

注意：线程对共享变量的所有操作都必须在自己的工作内存（working memory，是cache和寄存器的一个抽象，并不是内存中的某个部分）。不同线程之间，当前线程无法直接访问其他线程的工作内存中的变量，线程间变量值得传递需要通过主内存来完成。

**缓存一致性协议。**最出名的就是Intel 的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

**解决共享变量的内存可见问题的方式有很多**

**1、synchronized实现可见性**

JMM（Java内存模型）关于synchronized的两条规定：

线程解锁前，必须把共享变量的最新值刷新到主内存中，

线程加锁时，将清空工作内存中共享变量的值，从而使用共享变量时需要从主内存中重新读取最新的值。

public static void main(String[] args) {
            ThreadDemo threadDemo = new ThreadDemo();
            new Thread(threadDemo).start();
            while(true){
                // main线程加锁
                synchronized(threadDemo){
                    if(threadDemo.isFlag()){
                        System.out.println("----主线程读到flag为true----");
                        break;
                    }
                }
            }
        }

**2、volatile关键字实现可见性**

对于多线程， volatile不具备“互斥性”，不能保证变量状态的“原子性操作”。

使用 volatile 关键字用来确保将变量的更新操作通知到其他线程。

某个线程的工作内存中修改了共享变量的值并会刷新到主内存中，同时其他线程已经读取的共享变量副本就会失效，需要读数据时就会再次去主内存中读取新的共享变量的值，从而达到共享变量内存可见。

// 共享变量用 volatile修饰即可   
     private volatile boolean flag = false;

![20200617103501782.png][]

**synchronized 和 volatile比较**

synchronized具备“互斥性”，既能保证可见性，又能保证原子性，volatile不具备“互斥性”，只能保证可见性，不能保证原子性。

volatile不需要加锁，比synchronized更轻量级，不会阻塞线程，效率更高。如果能用 volatile解决问题，应尽量使用volatile，因为它的效率比synchronized更高。

### 二、原子性 ###

原子性：一次操作，要么全部执行成功，要么全部执行失败。一个很经典的例子就是银行账户转账问题。

**1、一个实例demo**

public class AtomicTest {
        public static void main(String[] args) {
            AtomicDemo atomicDemo = new AtomicDemo(0);
            for (int i = 0; i < 10; i++) {
                new Thread(atomicDemo).start();
            }
        }
    }
    
    class AtomicDemo implements Runnable{
        //线程共享变量
        private volatile int number;
    
        public AtomicDemo(int number) {
            this.number = number;
        }
    
        @Override
        public void run() {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread().getName() + ",number=" + ++number);
        }
    }

![20200618222440660.png][]

运行结果会发现可能会在不同的线程中，看到相同的数值，这是由于 volatile关键字保证了操作的内存可见性，但是 volatile不能保证操作的原子性。

自增操作不是原子性操作，它包括读取变量的原始值、进行加1操作、写入工作内存。而且volatile也无法保证对变量的任何操作都是原子性的。

**2、解决原子性操作问题--JUC**

**java.util.concurrent.atomic** 原子操作类包里面提供了一组原子变量类。封装了一系列常用的数据类型对应的封装类，

Java.util.concurrent.atomic 中实现的原子操作类可以分成4组：

> 标量类：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
> 
> 数组类：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
> 
> 更新器类：AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
> 
> 复合变量类：AtomicMarkableReference，AtomicStampedReference

这些类都保证了两点：

1）类里的变量都用了volatile保证内存是可见的

2）使用了一个算法CAS（Compare And Swap），保证对这些数据的操作具有原子性

public class AtomicTest1 {
    
        public static void main(String[] args) throws InterruptedException {
            //线程共享变量
            AtomicInteger atomicInteger = new AtomicInteger(0);
            AtomicDemo1 atomicDemo = new AtomicDemo1(atomicInteger);
            for (int i = 0; i < 10; i++) {
                Thread thread = new Thread(atomicDemo);
                thread.start();
            }
        }
    }
    
    class AtomicDemo1 implements Runnable{
        private AtomicInteger atomicInteger = null;
    
        public AtomicDemo1(AtomicInteger atomicInteger) {
            this.atomicInteger = atomicInteger;
        }
    
        @Override
        public void run() {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
            }
            System.out.println(Thread.currentThread().getName() + ",atomicInteger=" + atomicInteger.incrementAndGet());
        }
    }

![20200618222528216.png][]

参考文章：

[Java并发编程：volatile关键字解析][Java_volatile]

[阿里面试：跟我死磕Synchronized底层实现，我满分回答拿了Offer][Synchronized_Offer]

[20200617101509854.png]: https://img-blog.csdnimg.cn/20200617101509854.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200617102021419.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDAyODU0,size_16,color_FFFFFF,t_70
[20200617103501782.png]: https://img-blog.csdnimg.cn/20200617103501782.png
[20200618222440660.png]: https://img-blog.csdnimg.cn/20200618222440660.png
[20200618222528216.png]: https://img-blog.csdnimg.cn/20200618222528216.png
[Java_volatile]: https://www.cnblogs.com/dolphin0520/p/3920373.html
[Synchronized_Offer]: https://blog.csdn.net/qq_35190492/article/details/106180781