前言

这里的线程安全的问题大部分都能用synchronized解决,但是本章不会讨论这个重量型的解决方法,而是去探讨更好的方案和原理.本博客也有博主自己的一些理解.
本章的目录由于过于繁杂和详细,博主自己也是做了一个流程图给大家,以便大家更好的理解和整理.

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;}@Overridepublic 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 可能永远为0System.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.

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

方案： 在进行比较的时候，看一下主内存的值，是不是我之前读取的值，如果不是，我就不把值set到主内存啦，我重新读取住内存的值，然后进行+1的操作。 聪明的你，一直是这么想的对不对！！
因为有了这个解决方案，我们的AtomicInteger 早就帮我考虑好了这个方案的封装

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;}@Overridepublic 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啦 是2019System.out.println(atomicInteger.compareAndSet(5,1024+atomicInteger.get()));
输出结果truefalse

CAS的内部原理

总结就是自旋锁和Unsafe类
Unsafe类


根据上面我们可以知道 getAndAddInt是unSafe的方法,而Unsafe类天生就是java原句,他是天生原子性,他的所有方法都是安全的.

   //以下是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的缺点

1:因为do While 循环,所以可能循环时间长,开销比较大;
2: 只能保证一个共享变量的原子操作.因为他的var1值得就是当前对象
3:引出ABA问题(核心)

ABA问题

AB两个线程做操作,主内存的值为1,此时他们进行拷贝,他们各自的空间的值都为1
A线程把主内存的值1改为2,然后又该1, 此时B过来来修改至根据cas的期望值,他发现1就是他所期望的值,他认为并没有人对主内存进行修改过.这是不符合CAS的原理的.他只管开头和结尾,不关心中心的内容,这是不对的

原子引用解决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@16b4a017System.out.println(atomicReference.compareAndSet(user,user2)+"-->结果"+atomicReference.get().toString());//因为前面的操作 此时 主内存为李四,而这里他期待的是张三 所以修改失败  false-->结果com.bwie.demo.User@16b4a017System.out.println(atomicReference.compareAndSet(user,user2)+"-->结果"+atomicReference.get().toString());

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

| 线程名称| 变量内容 |修改次数 |
|–|–|–|–|
| T1 |100 | 1 |
| T2 |100 | 1 |
此时T1做了修改吧100修改为101 ,然后在修改回来100,中间操作了2次,此时修改次数加2

| T1 |100 | 3 |
|–|–|–|–|
| T2 |100 | 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();}
}

双端检索机制的隐患

从上面的结果我们可以看出来,好像加了双端检索机制貌似就没有出现问题啦, 而且运行检验的时候,他的确是只输出了一次构造方法吗?
但是问题真的就这么解决了吗?

DCL(双端检索机制)机制不一定安全,因为有指令重排的存在,加入voliate则可以禁止指令重排
原因是在某个线程执行到第一次检测,读取到instance为null的时候,instance对象没有完成对象的初始化,而
instance = new SingletonDemo();又可以分为三步
memory = allocate() 分配内存空间 语句1
instance(memory ) 初始化对象 语句2
instance = memory 实例指向内空间 语句3
因为语句2和语句3没有数据依赖性,所以 他们的顺序可以指令重排, 如果为132顺序的话.在对象还没有完成对象的初始化的时候,直接把null的对象指向内存空间,会导致出现null的结果

解决双端检索机制的隐患

加上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();}
}