package com.moxi.interview.study.thread;

/**
 * Volatile Java虚拟机提供的轻量级同步机制
 *
 * 可见性（及时通知）
 * 不保证原子性
 * 禁止指令重排
 */

import java.util.concurrent.TimeUnit;

/**
 * 假设是主物理内存
 */
class MyData {

    int number = 0;

    public void addTo60() {
        this.number = 60;
    }
}

/**
 * 验证volatile的可见性
 * 1. 假设int number = 0， number变量之前没有添加volatile关键字修饰
 */
public class VolatileDemo {

    public static void main(String args []) {

        // 资源类
        MyData myData = new MyData();

        // AAA线程 实现了Runnable接口的，lambda表达式
        new Thread(() -> {

            System.out.println(Thread.currentThread().getName() + "\t come in");

            // 线程睡眠3秒，假设在进行运算
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 修改number的值
            myData.addTo60();

            // 输出修改后的值
            System.out.println(Thread.currentThread().getName() + "\t update number value:" + myData.number);

        }, "AAA").start();

        while(myData.number == 0) {
            // main线程就一直在这里等待循环，直到number的值不等于零
        }

        // 按道理这个值是不可能打印出来的，因为主线程运行的时候，number的值为0，所以一直在循环
        // 如果能输出这句话，说明AAA线程在睡眠3秒后，更新的number的值，重新写入到主内存，并被main线程感知到了
        System.out.println(Thread.currentThread().getName() + "\t mission is over");

        /**
         * 最后输出结果：
         * AAA	 come in
         * AAA	 update number value:60
         * 最后线程没有停止，并行没有输出  mission is over 这句话，说明没有用volatile修饰的变量，是没有可见性
         */

    }
}

/**
 * 假设是主物理内存
 */
class MyData {
    /**
     * volatile 修饰的关键字，是为了增加 主线程和线程之间的可见性，只要有一个线程修改了内存中的值，其它线程也能马上感知
     */
    volatile int number = 0;

    public void addTo60() {
        this.number = 60;
    }
}

class MyData2 {

    // 注意！😈
    volatile int number = 0;


    // ❕ 此时number前面是加了volatile关键字修饰的，不保证原子性
    public void addPlusPlus() {
        number++;
    }
}

public class VolatileDemo2 {
    public static void main(String args[]) {

        MyData2 myData2 = new MyData2();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                // method
                for (int j = 0; j < 2000; j++) {
                    myData2.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }

        // 需要等待上面20个线程都全部计算完成后，再main线程取得最终的结果值看是多少？
        while(Thread.activeCount()>2){ // 默认后台有main线程和gc线程
            // 使当前线程由执行状态，变成为就绪状态，让出cpu时间，在下一个线程执行时候，此线程有可能被执行，也有可能没有被执行
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number value: "+myData2.number);

    }
}

// 在可见性的基础上增加原子性
class MyData3 {

    // 注意！😈
    AtomicInteger atomicInteger = new AtomicInteger();


    // ❕ 此时number前面是加了volatile关键字修饰的，不保证原子性
    public  void addPlusPlus() {
        atomicInteger.getAndIncrement();
    }
}

public class VolatileDemo3 {
    public static void main(String args[]) {

        MyData3 myData = new MyData3();
        for (int i = 0; i < 20; i++) {
            new Thread(() -> {
                // method
                for (int j = 0; j < 2000; j++) {
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }

        // 需要等待上面20个线程都全部计算完成后，再main线程取得最终的结果值看是多少？
        while(Thread.activeCount()>2){ // 默认后台有main线程和gc线程
            // 使当前线程由执行状态，变成为就绪状态，让出cpu时间，在下一个线程执行时候，此线程有可能被执行，也有可能没有被执行
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName()+"\t finally number value: "+myData.atomicInteger);

    }
}

public void mySort(){
  int x = 11; //语句1
  int y = 12; //语句2
  x = x + 5; //语句3
  y = x * x; //语句4
}