volatile关键字

volatile关键字是为了解决线程之间共享变量不可见问题。会强制刷新主内存的变量使线程能拿到最新的变量。

线程之前共享变量不可见问题：

package com.mock;

import org.junit.jupiter.api.Test;

public class TestVolatile {

    /**
     * 主线程永远不会打印消息
     */
    @Test
    public void test1() {
        //主线程和子线程共享t变量
        ThreadTest t = new ThreadTest();
        new Thread(t).start();

        while (true) {
            if ("Mock".equals(t.getName())) {
                System.out.println(t.getName());
            }
        }
    }


}

class ThreadTest implements Runnable {

    private String name = "Zhou";


    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println("name设置为：Mock");
            this.name = "Mock";
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

执行上面代码，主线程永远不会输出信息。

问题解释如下：

程序运行时JVM会给每一条线程开辟自己的工作内存，线程共享变量在主内存（堆内存）
一开始变量值为Zhou， Thread1线程和main线程从主内存拷贝一份数据在自己的工作内存空间，然后Thread1线程会把变量改为Mock，而main线程不会刷新内存空间，导致拿到的还是旧值。

问题解决方式1加锁：

   @Test
    public void test1() {
        //主线程和子线程共享t变量
        ThreadTest t = new ThreadTest();
        new Thread(t).start();

        while (true) {
            synchronized (t) {
                if ("Mock".equals(t.getName())) {
                    System.out.println(t.getName());
                }
            }
        }
    }

问题解决方式2 volatile关键字：

class ThreadTest implements Runnable {

    private volatile String name = "Zhou";

volatile关键字的效率比锁高

注意：
volatile 不具备互斥性，一条线程访问，另一条线程依然能访问（synchronized 具有互斥性）
volatile并不能保证变量的原子性