package cn.aparke.Interview;

import java.util.concurrent.atomic.AtomicInteger;
/**
验证volatile关键字 可见性 、原子性
@author aparke

1.volatile 关键字
volatile是Java虚拟机提供的轻量级的同步机制 
主要有三大特性：
1.1保证可见性：是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的
1.2不保证原子性：原子是世界上的最小单位，具有不可分割性
1.3有序性禁止指令重排：

JMM之内存模型可见性

JMM(Java内存模型 Java Memory Mode,简称JMM)
本身是一种抽象的概念并不真实存在,它描述的是一组规则或规范,通过这组规范定义了程序中各个变量(包括实例字段,
静态字段和构成数组对象的元素)的访问方式。

JMM关于同步的规定:
1线程解锁前,必须把共享变量的值刷新回主内存
2线程加锁前,必须读取主内存的最新值到自己的工作内存
3加锁解锁是同一把锁

由于JVM运行程序的实体是线程,而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间),工作内存是每个线程的私有数据区域,
而Java内存模型中规定所有变量都存储在主内存,主内存是共享内存区域,所有线程都可以访问,但线程对变量的操作(读取赋值等)必须在工作内存中进行,
首先要将变量从主内存拷贝的自己的工作内存空间,然后对变量进行操作,操作完成后再将变量“写回主内存”,不能直接操作主内存中的变量,
各个线程中的工作内存中存储着主内存中的变量副本拷贝,因此不同的线程间无法访问对方的工作内存,线程间的通信(传值)必须通过主内存来完成。
 */
class MyData extends Thread {
	
	//由于number没有关键字volatile 资源一将number修改后 main线程不知道，所以main方法的while一直死循环，
	
	//一旦被 volatile 修饰 由于它的可见性 会立马告诉别（main）的线程 number 已经修改了
//	int number = 0;
	volatile int number = 0;

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

	@Override
	public void run() {
		
		System.out.println(Thread.currentThread().getName() + "\t come in");
		try {
			Thread.sleep(10);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		addTo60();
		System.out.println(Thread.currentThread().getName() + "\t update number is "+number);
		
	}
}

class MyData2 extends Thread {
	
	volatile int number = 0;
	// int number = 0;

	//numberq前面加了关键字 volatile不保证原子性,，如果加上同步关键字synchronized则一定是20000个线程
	//在访问volatile变量时不会执行加锁操作，因此也就不会使执行线程阻塞，因此volatile变量是一种比sychronized关键字更轻量级的同步机制。
	public  void addPlusPLus() {
		number++;
	}
	
	//AtomicInteger原子类解决
	AtomicInteger atomicInteger =new AtomicInteger();
	public void addAtomic() {
		atomicInteger.getAndIncrement();//调一次加一次并得到这个值
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 1000; i++) {
			
			addPlusPLus();//不保证原子性
			addAtomic();//保证原子性
		}
	}

}
	
public class Volatile {

	/**
	 * 1验证volatile关键字 可见性 
	 * 	1.1加入int number=0，number变量之前根本没有添加volatile 关键字修饰 没有可见性
	 * 	1.2添加了volatile ，可以解决可见性问题
	 * 
	 * 2.验证volatile 不保证原子性
	 * 	2.1原子性指的是什么意思
	 * 		不可分割，完整的，也即被某个线程正在做具体业务时，中间可以被加载或者被分割。需要整体完整
	 * 		要么同时成功，要么同时失败
	 * 	2.2是否可以保证原子性
	 * 	2.3通过同步关键字synchronized解决，效率降低
	 * 		可以通过AtomicInteger原子操作类解决  详情百度AtomicInteger  了解点
	 * @param args
	 */

	public static void main(String[] args) {

		//volatile 可以保证可见性测试
		//seeOkByVolatile();
		
		// volatile不具有原子性
		seeNoAtomicity();
	}

//验证二 volatile不具有原子性
	public static void seeNoAtomicity() {
		MyData2 myData2 = new MyData2();
		for (int i = 0; i < 20; i++) {
			//创建20个线程设置线程，每个线程在run方法里执行1000次的名字为i的值
				Thread thread = new Thread(myData2);
				thread.setName(String.valueOf(i));
				thread.start();
		}
		
		//需要等待上面20个线程全部计算完成，再用main线程取得最终的结果值看是多少
		while (Thread.activeCount()>2) {//如果当前线程数量大于2 main线程给别的线程让道   此处的2代表的时 main线程 和gc线程
			Thread.yield();
		}
		System.out.println(Thread.currentThread().getName()+"\t 一共多少线程"+ myData2.number);//如果保证了原子性（给方法加上同步或者使用原子性类）打出的线程是20000 
		
		System.out.println(Thread.currentThread().getName()+"\t 使用原子性后一共多少线程"+ myData2.atomicInteger);//保证了原子性打出的线程是20000 
	}
	
	
	//验证一：volatile 可以保证可见性，及时通知其它线程，主物理内存的值已经被修改
	public static void seeOkByVolatile() {
		// 启动资源一 ，并设置线程名字为 资源一
		MyData myData = new MyData();
		myData.setName("资源一");
		myData.start();

		// 第二个资源就是我们的main线程
		while (myData.number == 0) {
			// main线程一直在这等待循环，直到number的值 不在为0结束
		}
		// main资源打印一句话
		System.out.println(Thread.currentThread().getName() + "\t mission is over ,main get value is " + myData.number);
	}
}