可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到 修改的值。

下面是模拟两个线程对共享变量操作的例子，用来分析线程间的可见性问题

@Slf4j
public  class VisibilityTest {

    // volatile   -> lock addl $0x0,(%rsp)
    private  boolean flag = true;
   // private volatile boolean flag = true;
    //private volatile int count;


    public  synchronized void refresh() {
        // 希望结束数据加载工作
        flag = false;
        System.out.println(Thread.currentThread().getName() + "修改flag:"+flag);
    }

    public void load() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        while (flag) {
            //TODO  业务逻辑：加载数据
            //shortWait(10000);
            //synchronized可以保证可见性
            //System.out.println("正在加载数据......");
           // count++;
            //添加一个内存屏障   可以保证可见性
            //UnsafeFactory.getUnsafe().storeFence();
//            try {
//                Thread.sleep(0);
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
            //Thread.yield(); //让出cpu使用权

        }

        System.out.println(Thread.currentThread().getName() + "数据加载完成，跳出循环");
    }


    public static void main(String[] args) throws InterruptedException {
        VisibilityTest test = new VisibilityTest();


        // 线程threadA模拟数据加载场景
        Thread threadA = new Thread(() -> test.load(), "threadA");
        threadA.start();

        // 让threadA先执行一会儿后再启动线程B
        Thread.sleep(1000);

        // 线程threadB通过修改flag控制threadA的执行时间，数据加载可以结束了
        Thread threadB = new Thread(() -> test.refresh(), "threadB");
        threadB.start();

    }

当flag没有volatile修饰时，不可见，执行结果线程A跳不出循环

运行结果：threadA没有跳出循环，也就是说threadB对共享变量flag的更新操作对threadA不可见， 存在可见性问题。

思考：上面例子中为什么多线程对共享变量的操作存在可见性问题？

当flag有volatile修饰时，具有可见性，执行结果线程A可以跳循环

当flag没有volatile修饰时，但是在load()方法内的while()中输出打印语句，如：System.out.println("正在加载数据......")后，，执行结果线程A还是可以跳循环，原因是println（）方法内有synchronized (this)，具有可见性。

当flag没有volatile修饰时，但是在load()方法内的while()中加上内存屏障后，执行结果线程A也是可以跳循环，具有可见性。

public class UnsafeFactory {

    /**
     * 获取 Unsafe 对象
     * @return
     */
    public static Unsafe getUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取字段的内存偏移量
     * @param unsafe
     * @param clazz
     * @param fieldName
     * @return
     */
    public static long getFieldOffset(Unsafe unsafe, Class clazz, String fieldName) {
        try {
            return unsafe.objectFieldOffset(clazz.getDeclaredField(fieldName));
        } catch (NoSuchFieldException e) {
            throw new Error(e);
        }
    }


}

当flag没有volatile修饰时，但是在load()方法内的while()中线程睡眠的方法：如  Thread.sleep(0);后，执行结果线程A也是可以跳循环，sleep(0)方法内部调用了内存屏障，具有可见性！

        当sleep中的时间值为0时，相当于调用了Thread.yield(); 让出cpu使用权

如何保证可见性

        1. 通过 volatile 关键字保证可见性

        2. 通过 内存屏障保证可见性

        3. 通过 synchronized 关键字保证可见性