volatile

volatile是JAVA虚拟机提供的轻量级的同步机制

volatile特点：
1、保证了可见性
2、不保证原子性
3、禁止指令重排，保证了有序性

JMM（java内存模型）特性：

• 1】可见性

• 2】原子性

• 3】有序性
  
  可见性：
  
  当一个线程对共享变量的值进行拷贝到自己的工作内存 再进行修改 再写入主内存中之后，会对其他的操作该变量的线程通知，其他线程就知道自己拷贝到自己工作内存的值出现了修改，其他线程马上获得修改之后的值。

   class Data{
   		volatile int number=0;
   			
   		public void setData(){
   				this.number=60;
   			}
   		}
   	    /**
   	     *  可见性
   	     */
   	    	private static void SeeOk() {
   	    				Data data = new Data();   			 
   	    			     new Thread(new Runnable() {			
   	    					@Override
   	    					public void run() {
   	    						System.out.println("线程"+Thread.currentThread().getName()+"come");
   	    						try {
   	    							TimeUnit.SECONDS.sleep(3);
   	    						} catch (InterruptedException e) {
   	    							e.printStackTrace();
   	    						}
   	    						data.setData();
   	    						System.out.println("线程"+Thread.currentThread().getName()+" number为："+data.number);
   	    					}
   	    				},"AAA").start();    		    
   	    			     while(data.number==0){    		    	 
   	    			     }
   	    			     System.out.println("main get number value"+data.number);
   	    			}
  

上述中如果主线程知道number的值发生改变，那么while循环将退出。

不保证原子性
原子性：不可分割，完整性，也即某个线程正在做某个业务时，中间不可以被加塞或者被分割。需要整体完整
要么同时成功，要么同时失败。
为什么不保证原子性：
出现丢失写值得状况
i++ 分3步
第一步 读取主内存中的值到线程工作空间
第二部 进行+操作
第三步 把数值再写回到主内存

class Data{
	volatile int number=0;
	public void addNumber(){
		number++;
	}    	
	AtomicInteger atomicInteger = new AtomicInteger();
	public void atomic() {
		atomicInteger.getAndIncrement();
	}
}

main 函数：

 public static void main(String[] args) {
					 Data data = new Data();
					  for (int i = 0; i <20; i++) {
						new Thread(()->{
							for (int j = 1; j <=1000; j++) {
								data.addNumber();
								data.atomic();
							}
						},String.valueOf(i)).start();
					}
			      
					  while(Thread.activeCount()>2){
						  Thread.yield();
					  }
					  System.out.println(Thread.currentThread().getName()+"\t volatile finally number value :"+data.number);
					  System.out.println(Thread.currentThread().getName()+"\t atomicInteger finally number value :"+data.atomicInteger);
				}

运行结果： 如果volatile保证了原子性，那么值应该为20000.

既然volatile不保证原子性，我们可以使用JUC下的atomic类下的类
如：Class AtomicInteger 或者 Class AtomicReference
保证了原子性。

指令重排