并发专题之—Voliate引发的各种原理问题

大家好，欢迎来到IT知识分享网。

前言

JMM

voliate

voliate是java虚拟机提供的轻量级的同步机制.他保证了可见性,不保证原子性,禁止指令重排

不保证原子性

代码案例

package com.bwie.demo; / * 不能保证原子性 * 理论来个每个线程+1000 结果为2000,但是结果却是小于2000的值 */ public class VolatileUnsafe2 { 
    private volatile long count =0; public long getCount() { 
    return count; } public void setCount(long count) { 
    this.count = count; } //count进行累加 public void incCount(){ 
    count++; } //线程 private static class Count extends Thread{ 
    private VolatileUnsafe2 simplOper; public Count(VolatileUnsafe2 simplOper) { 
    this.simplOper = simplOper; } @Override public void run() { 
    for(int i=0;i<10000;i++){ 
    simplOper.incCount(); } } } public static void main(String[] args) throws InterruptedException { 
    VolatileUnsafe2 simplOper = new VolatileUnsafe2(); //启动两个线程 Count count1 = new Count(simplOper); Count count2 = new Count(simplOper); count1.start(); count2.start(); Thread.sleep(50); // 这个必须添加,不然你getcount 可能永远为0 System.out.println(simplOper.count);//20000? } } 

不保证原子性的解释

根据JMM模型,我们可以知道,当加了voliate之后,每当在自己的内存空间写完后,需要通知其他线程自己做了修改,其他线程读取其他的线程.为什么还会有不正确的值呢?

注意：voliate 只保证可见性，重点侧重于: 每个可以拿到其他线程修改之后的最新值（但并不是意味，只要有新值就可以实时获取最新值）

在上面的列子中，如果当count = 100的时候，此时A，B 因为voliate的可见性，可以拿到主内存的新值，但是此时a，b两个线程他们做的都是100+1的操作，假如此时B线程完成了100+1的操作，设置到主内存，此时主内存为101，但是A线程还没有结束任务呀，此时他让仍然继续执行100+1的操作，相当于住内存的值 又覆盖了一遍101

有同学会问啦，不知加了voliate，会通知其他线程，读取主内存的最新值，为什么A线程还在进行100+1的操作呀，他不是应该中断这个操作，重新读取主内存的值101，然后进行101+1的操作？

如果你真的这么想，那么只能说明你对原子性和可见性含义搞蒙啦（当然，我之前 也懵了好久）

可见性：他只会保证每个线程读取的值，是上一个线程修改之后的最新值，也就是主内存的，比如count 进行100+1的操作，此时100必定是上一个线程操作之后的结果。此时他侧重的是：在我获取主内存的那一瞬间，主内存的值是最新的，注意关键词 获取主内存的那一瞬间，主内存的值最新的，就跟上面的列子一样，此时A，B他们获取到的值都是100，都是最新的，此时已经满足了可见性。

此时假如B线程完成了100+1的操作，此时主内存已经是101，A之所以不会中断100+1的操作，重新读取主内存的值，是因为可见性的特点是：获取主内存的那一瞬间，主内存的值新的，而此时他已经不是获取主内存的时间，而是在自己的内存中进行修改，此时他就会把自己的设置的101又进行一遍住内存赋值，但是A，B 两个线程下一次他去主内存获取值的时候绝对是保证是101.

那我考考大家，如果大家要解决这个问题该怎么做呀？

AtomicInteger解决不保证原子性的问题

package com.bwie.demo; import java.time.temporal.ValueRange; import java.util.concurrent.atomic.AtomicInteger; / * 不能保证原子性 */ public class VolatileUnsafe2 { 
    AtomicInteger count = new AtomicInteger(0); public void addCount(){ 
    count.getAndIncrement(); } static class MyData extends Thread{ 
    private VolatileUnsafe2 simplOper; public MyData(VolatileUnsafe2 simplOper) { 
    this.simplOper = simplOper; } @Override public void run() { 
    for (int i = 0; i <1000 ; i++) { 
    simplOper.addCount(); } } } public static void main(String[] args) throws InterruptedException { 
    VolatileUnsafe2 volatileUnsafe2 = new VolatileUnsafe2(); MyData myData = new MyData(volatileUnsafe2); MyData myData1 = new MyData(volatileUnsafe2); try { 
    Thread.sleep(50); } catch (InterruptedException e) { 
    e.printStackTrace(); } myData.start(); myData1.start(); Thread.sleep(5000); System.out.println(volatileUnsafe2.count); } } 

为什么AtomicInteger可以解决原子性问题?

CAS

什么是cas
CAS:又称为CompareAndSwap 比较并且交换,在我们上面的分析中,我们可以知道,因为即便加了voliate还是会有原子性的问题,其核心问题所在就是希望设置主内存值进行设置的时候,期望没有人对其修改过.而cas就是在修改的时候, 有会一个期望值,如果和期望一样的话,就说明没有修改过.此时可以进行正常设置值,他是原语,天生安全

案例

AtomicInteger atomicInteger = new AtomicInteger(5); System.out.println(atomicInteger.compareAndSet(5,2019+atomicInteger.get())); //此时实际值已经不是5啦 是2019 System.out.println(atomicInteger.compareAndSet(5,1024+atomicInteger.get())); 输出结果 true false 

CAS的内部原理

 //以下是getAndIncrement的内部源码 public final int getAndIncrement() { 
    / * arg0:当前对象 * arg1:内存偏移量 * arg2:自增量 * 大概意思就是当前对象的这个值为多少 / return unsafe.getAndAddInt(this, valueOffset, 1); } 

下面这个源码是cas的核心精华所在

public final int getAndAddInt(Object var1, long var2, int var4) { 
    int var5; do { 
    //get 方法, 根据当前对象的偏移量 得到具体的当前对象 var5 = this.getIntVolatile(var1, var2); //得到主内存的值 //var1 auomicInteger本身 //var2 该对象值得引用地址 //var4 需要改动的数量 //var5 是用过var1和var2找出的主内存中真实值 //知道修改成功啦.会跳出循环  } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; } 

CAS的缺点

ABA问题

原子引用解决ABA问题

先介绍下原子引用: 前面的aticInteger只能解决int类型,但是如果是对象怎么办呢?

原子引用的简单代码了解

 User user = new User("张三", 1); User user2 = new User("李四", 2); AtomicReference<User> atomicReference = new AtomicReference<>(); //主物理内存为张三 atomicReference.set(user); //张三变更为李四 //因为user 和 前面的主物理内存相同,所以根据cas可以修改 true-->结果com.bwie.demo.User@16b4a017 System.out.println(atomicReference.compareAndSet(user,user2)+"-->结果"+atomicReference.get().toString()); //因为前面的操作 此时 主内存为李四,而这里他期待的是张三 所以修改失败 false-->结果com.bwie.demo.User@16b4a017 System.out.println(atomicReference.compareAndSet(user,user2)+"-->结果"+atomicReference.get().toString()); 

时间戳的原子引用解决ABA问题
最好的办法就是在每次操作的时候加上版本号, 类似乐观锁,加入此时有两个线程T1 T2
但是每次线程修改的时候,都需加上一个版本字段,每次修改依次增加1 比如下面的列子

public class SingletonDemo { 
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100); public static void main(String[] args) { 
    new Thread(() -> { 
    System.out.println(Thread.currentThread().getName()+"==="+atomicReference.compareAndSet(100, 101));; System.out.println(Thread.currentThread().getName()+"==="+atomicReference.compareAndSet(101, 100));; }, "t1").start(); new Thread(() -> { 
    try { 
    Thread.sleep(50); } catch (InterruptedException e) { 
    e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"==="+atomicReference.compareAndSet(100, 2019)); }, "t2").start(); } } 输出结果 t1===true t1===true t2===true 

上面的例子并不能解决ABA问题,接下来,我们看一下解决方案

public class SingletonDemo { 
    static AtomicReference<Integer> atomicReference = new AtomicReference<>(100); static AtomicStampedReference<Integer> atomicStampedReference = new AtomicStampedReference<Integer>(100,1); public static void main(String[] args) { 
    new Thread(() -> { 
    int stamp = atomicStampedReference.getStamp(); try { 
    Thread.sleep(1); } catch (InterruptedException e) { 
    e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"第一次版本号"+stamp); //暂停一秒 System.out.println(Thread.currentThread().getName()+"===>"+atomicStampedReference.compareAndSet(100, 101,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1));; System.out.println("第二次版本号"+atomicStampedReference.getStamp()+"实际内容"+atomicStampedReference.getReference()); System.out.println(Thread.currentThread().getName()+"===>"+atomicStampedReference.compareAndSet(101, 100,atomicStampedReference.getStamp(),atomicStampedReference.getStamp()+1));; System.out.println("第三次版本号"+atomicStampedReference.getStamp()+"实际内容"+atomicStampedReference.getReference()); }, "t1").start(); new Thread(() -> { 
    int stamp = atomicStampedReference.getStamp(); //让他们都拿到初始的值 try { 
    Thread.sleep(8000); // 等待,让t2看不到aba出现的过程 } catch (InterruptedException e) { 
    e.printStackTrace(); } System.out.println(Thread.currentThread().getName()+"的期望值为"+stamp); System.out.println(Thread.currentThread().getName()+"===>"+atomicStampedReference.compareAndSet(100, 2019,stamp,stamp+1)); System.out.println("第三次版本号"+atomicStampedReference.getStamp()+"实际内容"+atomicStampedReference.getReference()); }, "t2").start(); } } t1第一次版本号1 t1===>true 第二次版本号2实际内容101 t1===>true 第三次版本号3实际内容100 t2的期望值为1 t2===>false 第三次版本号3实际内容100 

禁止指令重排

我们首先看一下例子
案例一

数据依赖性:在多线程的也可以能2134. 因为x和y的声明互相不影响对方,所以可以指令重排,但是不能3124, 因为必须现有x的声明,才能进行x的操作,所以此时不能进行指令重排
案例二

在下面的代码里面,因为指令重排很可能会出现如下的问题;

案例3

以上的代码如果出现1,2的位置互换,在多线程的环境下,此时另一个线程调用method2的时候,此时他会先读取flag=true,而此时的 a并没有赋值,此时默认为0

多线程环境下单例模式出现的问题

package com.bwie.demo; import java.time.temporal.ValueRange; import java.util.concurrent.atomic.AtomicInteger; / * 不能保证原子性 */ public class SingletonDemo { 
    public static SingletonDemo instance = null; public SingletonDemo() { 
    System.out.println("我是构造方法"); } private static SingletonDemo getInstance(){ 
    if (instance==null){ 
    instance = new SingletonDemo (); } return instance; } public static void main(String[] args) { 
    SingletonDemo instance = SingletonDemo.getInstance(); SingletonDemo instance1 = SingletonDemo.getInstance(); System.out.println(instance.equals(instance1)); } } 

public class SingletonDemo { 
    public static SingletonDemo instance = null; private SingletonDemo() { 
    System.out.println("我是构造方法"); } private static SingletonDemo getInstance() { 
    if (instance == null) { 
    instance = new SingletonDemo(); } return instance; } public static void main(String[] args) { 
    ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { 
    executorService.submit(() -> { 
    instance = SingletonDemo.getInstance(); }); } executorService.shutdown(); } } 

输出结果

我是构造方法 我是构造方法 我是构造方法 

双端检索机制解决办法

双端检索机制

public class SingletonDemo { 
    public static SingletonDemo instance = null; private SingletonDemo() { 
    System.out.println("我是构造方法"); } private static SingletonDemo getInstance() { 
    if (instance == null) { 
    synchronized (SingletonDemo.class) { 
    if (instance==null){ 
    instance = new SingletonDemo(); } } } return instance; } public static void main(String[] args) { 
    ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { 
    executorService.submit(() -> { 
    instance = SingletonDemo.getInstance(); }); } executorService.shutdown(); } } 

双端检索机制的隐患

解决双端检索机制的隐患

加上voliate

public class SingletonDemo { public static volatile SingletonDemo instance = null; private SingletonDemo() { System.out.println("我是构造方法"); } private static SingletonDemo getInstance() { if (instance == null) { synchronized (SingletonDemo.class) { if (instance==null){ instance = new SingletonDemo(); } } } return instance; } public static void main(String[] args) { ExecutorService executorService = Executors.newFixedThreadPool(10); for (int i = 0; i < 10; i++) { executorService.submit(() -> { instance = SingletonDemo.getInstance(); }); } executorService.shutdown(); } }