package com.tuling.juc.service;
import com.tuling.concurrent.lock.UnsafeInstance;
import com.tuling.juc.Factory.UnsafeFactory;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.LockSupport;
/**
 * @Description
 * @Author zhenghao
 * @Date 2021/10/28 18:26
 **/
public class VisibilityTest {
    //volatile  是通过内存屏障来实现 可见性 ，汇编层面 会在执行的指令前面 增加  lock关键字
    //lock 关键字 可以起到和内存屏障一样的作用，但不是内存屏障
    //lock 前缀指令 会等待它之前所有的指令都完成，并且所有缓冲的写操作写会内存
    private volatile boolean flag = true;
    private int count = 0;
    public void refresh() {
        flag = false;
        System.out.println(Thread.currentThread().getName() + "修改flag");
    }
    public void load() {
        System.out.println(Thread.currentThread().getName() + "开始执行.....");
        int i = 0;
        while (flag) {
            i++;
            count++;
            //TODO  业务逻辑
            //等待足够长的时间的时候，本地内存中的变量值会被主动刷新到主内存中
            //没有这句代码的时候，程序不会中断，这是因为whil true 计算机任务flag这个
            //变量随时都会被用到，所以就不会刷新到主内存中
            //shortWait(1000000);
            //下面这种方式，是如何解决可见性呢？线程上下文切换 加载上下文
//            Thread.yield();//使当前线程由运行态 转换成 就绪态，让出CPU占用时间
            //通过内存屏障来实现 可见性
//            UnsafeFactory.getUnsafe().storeFence();
            // 底层使用到了 synchronized 该关键字 最后也是调用了 storeFence方法
            //通过 内存屏障 实现 可见性
//            System.out.println(count);
//            LockSupport.unpark( Thread.currentThread());
//
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
            //总结 java保证 可见性 分为两种方式
            // 1、 内存屏障 jvm层面的 storeLoad内存屏障  === > X86 lock 替代了 mfence
            // 2、线程上下文切换Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "跳出循环: i=" + i);
    }
    public static void shortWait(long interval) {
        long start = System.nanoTime();
        long end;
        do {
            end = System.nanoTime();
        } while (start + interval >= end);
    }
    public static void main(String[] args) throws Exception {
        VisibilityTest visibilityTest = new VisibilityTest();
        Thread threadA = new Thread(() -> visibilityTest.load(), "ThreadA");
        threadA.start();
        Thread.sleep(1000);
        Thread threadB = new Thread(() -> visibilityTest.refresh(), "ThreadB");
        threadB.start();
    }
}

inline void OrderAccess::storeload()  { fence(); }
inline void OrderAccess::fence() {
  if (os::is_MP()) {
    // always use locked addl since mfence is sometimes expensive
#ifdef AMD64
    __asm__ volatile ("lock; addl $0,0(%%rsp)" : : : "cc", "memory");
#else
    __asm__ volatile ("lock; addl $0,0(%%esp)" : : : "cc", "memory");
#endif
  }