基础学习-01-volatile

柔光的暖阳◎ 2022-04-24 13:24 214阅读 0赞

1.volatile是**java虚拟机提供的一种稍弱的同步机制**。  
三个特性：**保证可见性、不保证原子性、禁止指令重排（有序性）**  
（1）可见性  
可见性，是指线程之间的可见性，一个线程修改的状态对另一个线程是可见的。  
在 Java 中 volatile、synchronized 和 final 实现可见性。  
（2）原子性  
原子是世界上的最小单位，具有不可分割性。在Java中，对基本数据类型的变量的读取和赋值操作是原子性操作，即这些操作是不可被中断的，要么全部执行，要么都不执行。  
在 Java 中 synchronized 和 lock、unlock 中操作保证原子性，而volatile不保证原子性。  
（3）有序性  
按顺序执行。Java提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性。  
volatile 是其本身包含“禁止指令重排序”的语义。  
synchronized 则是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”获得的，该规则决定了持有同一个对象锁的两个同步块只能串行执行。  
JMM具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，通常也称之为 happens-before 原则。如果两个操作的执行次序无法从该原则推导出来，那么就不能保证它们的有序性，而虚拟机则可以随意地对它们进行重排序。

2.JMM(java内存模型)：一种规范，并不真实存在。一有变化，其他线程就会收到变化通知（可见性）

![JMM-JAVA内存模型][JMM-JAVA]

*  java内存模型规定所有变量都存储在主内存中，主内存是共享内存区域，所有线程均可以访问主内存。
 *  线程对变量的操作（读取赋值等）必须在工作内存（本地内存）中进行，不能直接对主内存中的共享变量进行操作
 *  线程对变量的操作：先将共享变量从主内存拷贝到自己的工作内存（本地内存）空间中，然后对共享变量副本进行操作（读取赋值等），操作完成后将变量写回主内存。

3.通过例子解析volatile的特性  
（1）保证可见性  
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile关键字修饰，那么就该变量就具有可见性、禁止指令重排，但不保证原子性。

package cn.chen.demo;
    
    import java.util.concurrent.TimeUnit;
    
    class MyData{ 
    	//int number = 0;
    	volatile int number = 0;
    	public void addTo10(){ 
    		this.number = 10;
    	}
    }
    
    /** * 1.验证volatile的可见性 * 1) 假如 int number = 0; * number变量之前根本没有添加volatile关键字修饰 * 结论：可以看出线程AAA把number改成10，并写回了主内存， * 但没有通知线程main，因此main仍然认为number=0,一直卡在while循环体那里。 * （变量的更新操作没有通知到其他线程，导致线程陷入死循环） * 2) 修改添加 volatile int number = 0; * 结论：可见线程AAA走完后，main线程也执行了，并且值变成了10 * （添加volatile修饰确保了变量的更新操作通知到了其他线程，对其他线程是可见的。） * @author chenlf * */
    public class VolatileDemo { 
    	//main 一切方法的运行入口
    	public static void main(String[] args) { 
    		MyData myData = new MyData();//资源类
    		//第一个线程
    		new Thread(()->{ 
    			System.out.println(Thread.currentThread().getName()+"线程进入");
    			try { 
    				TimeUnit.SECONDS.sleep(3);//暂停线程3s
    			} catch (Exception e) { 
    				e.printStackTrace();
    			}
    			myData.addTo10();
    			System.out.println(Thread.currentThread().getName()
    					+" updated number value:"+myData.number);
    		},"AAA").start();
    		
    		//第二个线程：就是main主线程
    		while (myData.number == 0) { 
    			//main线程一直在这里等待循环，直到number不等于0；
    		}
    		System.out.println(Thread.currentThread().getName()
    				+" mission is over,"+Thread.currentThread().getName()+" get number value："+myData.number);
    	
    	}
    }

（2）不保证原子性  
可通过synchronized、atomicInteger、atomicLong、atomicReference来保证。  
（3）禁止指令重排

*  单例模式在多线程环境下可能存在安全问题

package cn.chen.demo.singletondemo;
    
    public class SingletonDemo { 
    	
    	private static SingletonDemo instance = null;
    	
    	private SingletonDemo() { 
    		System.out.println("构造方法");
    	}
    	
    	public static synchronized SingletonDemo getInstance() { 
    		if (instance == null) { 
    			instance = new SingletonDemo();
    		}
    		return instance;
    	}
    	
    	public static void main(String[] args) { 
    		//单线程（main线程的操作）
    		//不加synchronized，构造方法只执行一次
    		/*System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); System.out.println(SingletonDemo.getInstance() == SingletonDemo.getInstance()); */
    		//并发多线程
    		//1.构造方法执行了多次
    		//2.加synchronized修饰后，构造方法只执行了一次
    		for (int i = 0; i < 10; i++) { 
    			new Thread(()->{ 
    				SingletonDemo.getInstance();
    			}, String.valueOf(i)).start();;
    		}
    	}
    }

*  单例模式volatile分析

package cn.chen.demo.singletondemo;
    
    public class SingletonDemo { 
    	//添加 volatile 修饰，禁止指令重排
    	private static volatile SingletonDemo instance = null;
    	
    	private SingletonDemo() { 
    		System.out.println(Thread.currentThread().getName()+" 构造方法");
    	}
    	
    	//DCL(Double Check Lock) 双端检锁机制 :加锁前后都进行判断
    	//DCL机制不一定线程安全：原因是有指令重排序的存在，因此需要加入volatile禁止指令重排
    	public static SingletonDemo getInstance() { 
    		//加锁前进行判断
    		if (instance == null) { 
    			synchronized (SingletonDemo.class) { 
    				//加锁后再进行判断
    				if (instance == null) { 
    					instance = new SingletonDemo();
    				}
    			}
    		}
    		return instance;
    	}
    	
    	public static void main(String[] args) { 
    		//并发多线程:
    		for (int i = 1; i <= 10; i++) { 
    			new Thread(()->{ 
    				SingletonDemo.getInstance();
    			}, String.valueOf(i)).start();;
    		}
    	}
    }

[JMM-JAVA]: /images/20220214/768f52acba7a407ca0fc0e4bf7d0ecd1.png