小狼-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("线程执行完毕");
    }
}

Unsafe类

作用： Unsafe类存在于sun.misc包中，其内部方法操作可以像C的指针一样直接操作内存，Unsafe类中的所有方法都是native修饰的，也就是说Unsafe类中的方法都直接调用操作系统底层资源执行相应任务

底层：

是使用了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;
    }

 

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

 

 

再向下就是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是自旋锁，既保证了一致性，又保证了并发性

 

例子：

//拿过来时候是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了