多线程操作变量之CAS自旋锁

问题：

当多线程操作同一数据时候会发生错误

如创建两个进程共同操作共享变量static

 

代码：

public class test02 {    public static void main(String[] args) throws InterruptedException {        MyThread02 myThread02 = new MyThread02();        myThread02.start();        MyThread02 myThread022 = new MyThread02();        myThread022.start();        Thread.sleep(2000);//为了让所有进程都运行完毕        System.out.println(myThread02.a);   } } class MyThread02 extends Thread{    public  static int a = 0; ​    @Override    public void run() {        for (int i=0;i<30000;i++){            a++;       }        System.out.println("线程执行完毕");   } } ​ //输出： ​ //线程执行完毕 //46011

此时的运行结果并不会得到我们预想的结果

 

原因：

a放在方法区的静态区

当多个线程共同操作一个数据时候

两个线程操作时候都会复制一份数据到自己进程内存中

当自己更新后一个值后，将更新后的值放到原内存供其他线程使用

如：

线程一和线程二都修改初始值为0的a：

线程一将a+1后变为2，此时去更改方法区的a，将0变为1；

线程二将a+1后变为2，此时去更改方法区的a，本来应该将0变为1；

但此时线程一已经改过了，线程二并不知道，所以就会产生脏数据

最终导致：

虽然一共该增加60000次，但是由于他们的重复操作导致无法到达我们预期的结果

 

解决方法：

多线程有专门操作数据的对象

如int类型-》AtomicInteger

将a的数据类型变为AtomicInteger，增加时候使用方法 a.getAndIncrement();

class MyThread03 extends Thread{    public  static AtomicInteger a = new AtomicInteger(0); ​    @Override    public void run() {        for (int i=0;i<30000;i++){            a.getAndIncrement();       }        System.out.println("线程执行完毕");   } }

 

底层：

是使用了CAS原理：

何为CAS？

CAS就是比较与交换，全称为Compare-And-Swap，使用的Unsafe类+自旋锁思想；他是一条CPU并发原语

原语操作：原语操作是连续的，且执行过程中不允许被打断

CAS并发原语体现在使用java语言的unsafe类中的CAS方法，JVM会帮我们实现出CAS的汇编语言，这是一种完全依赖于硬件的功能，通过他实现了原子操作

所以使用CAS并不会产生上诉代码的数据不一致问题

 

源码：

 

getAndIncrement()

public final int getAndIncrement() {  //当前数据---当前数据地址值---每次需要加的值（+1）        return unsafe.getAndAddInt(this, valueOffset, 1);   }

 

getAndAddInt(this, valueOffset, 1)

   public final int getAndAddInt(Object var1, long var2, int var4) {        int var5;        do {            var5 = this.getIntVolatile(var1, var2);       } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); ​        return var5;   }

再向下就是native本地方法，是用c语言操作的

public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);

 

这里是一个自旋锁:getAndAddInt(this, valueOffset, 1) ​ 比较一下，如果传过来的var1和当前地址var2中存放的var5是否一样:compareAndSwapInt(var1, var2, var5, var5 + var4) ​ 如果比较成功了，地址里面的值没有人动过，则！变为false，退出循环 ​ 如果比较失败了，那么证明var5被改变过，！变为true，再运行一次 ​ 使用的是unsafe原理来保证原子性 ​ 这里while是自旋锁，既保证了一致性，又保证了并发性

 

var1： AtomicInteger对象本身 var2： 该对象的引用地址 var4： 需要变动的数量 var5： 用var1和var2找出的内存中的真实的值

 

例子：

//拿过来时候是5，期望算回来别人还没有改动过，还是为原来的5 //第一个可以修改成功，第二个修改失败 System.out.println(atomicInteger.compareAndSet(5, 2019)+"\tcurren date:"+atomicInteger.get()); ​ System.out.println(atomicInteger.compareAndSet(5, 1024)+"\tcurren date:"+atomicInteger.get());

 

此时我们第一次修改是可以成功的，因为我们比较时候拿出来希望是原来的数据为5就去修改为8019，此时定义的数据就是5，所以我们修改 但是第二次数据已经被修改为了8019，与我们的期望值5不同，所以就不再去修改为1024了