原子类与自旋锁原理初探

  • 1. 原子性
  • 2. 原子变量
    • (1) 内部的CAS
    • (2) Unsafe类
    • (3) CAS的缺点
    • (4) 乐观锁
  • 3. 原子引用
    • (1) AtomicReference和AtomicInteger的差异
    • (2) 解决ABA问题
      • 自旋锁+版本(时间戳)比对
        • 源码分析
        • 使用示例
  • 4. 自旋锁
    • 自己实现一个自旋锁

1. 原子性

原子性是指在一个操作中就是cpu不可以在中途暂停然后再调度,既不被中断操作,要不执行完成,要不就不执行

也就是一个线程在某个代码块的执行过程中,不能被其他线程抢用cpu资源而导致中断

2. 原子变量

此篇博客为介绍原子类的部分原理为主

有关原子类的详细介绍可以看这位大佬的博客 Java16个原子类介绍-基于JDK8

原子变量属于原子类,本质是对一些基本类型包装类的升级

原子类中的原子变量,采用了以下两点保证可见性和原子性

  • volatile 修饰内部的值保证可见性
  • 使用CAS算法保证数据的原子性
    原子类与自旋锁原理初探_第1张图片

(1) 内部的CAS

以AtomicInteger原子变量的getAndAdd(int dalta)方法为例
在这里插入图片描述
下面写错了,不是c++的代码,就是java的,因为一直没用过do while,都忘了java也有do while的循环语法…
原子类与自旋锁原理初探_第2张图片
CAS算法是对于并发操作共享数据的支持

CAS算法的3个操作数

  1. 内存值 (V)
  2. 预估值 (A)
  3. 更新值 (B)
    仅当V==A的时候,V=B,否则就不进行任何操作
  • 比较和替换是一步原子性操作,不能被其他线程抢用

(2) Unsafe类

原子类中的CAS算法本质是调用Unsafe类中的native本地方法去对数据进行操作(直接调用c++对内存进行操作,所以效率也会比较快)
原子类与自旋锁原理初探_第3张图片

(3) CAS的缺点

CAS算法虽然能实现自旋锁,但是有以下3个缺点

  • 循环会耗时
  • 一次性只能保证一个共享变量的原子性
  • ABA问题

(4) 乐观锁

乐观锁有两种实现:自旋锁和版本比对

自旋锁

自旋锁也就是使用普通的CAS算法,在后序章节会有详解

自旋锁容易出现上述的ABA问题 也就是数据是期望的,但是是被其他线程动过的数据,比如将2020->2021->2020,虽然最后还是2020,但已经被动过了

版本比对

比如一个线程执行任务,就会比对数据的版本号,如果版本号没有被其他线程动过,那么才对数据进行操作

3. 原子引用

原子引用指的也就是AtomicReference,作用是对"对象"进行原子操作。

它提供了一种读和写都是原子性的对象引用变量,同样采用CAS,不过内存值和预估值是比较对象的地址

(1) AtomicReference和AtomicInteger的差异

  • AtomicInteger是对整数的封装,底层采用的是compareAndSwapInt实现CAS,比较的是数值是否相等

  • AtomicReference则对应普通的对象引用,底层使用的是compareAndSwapObject实现CAS,比较的是两个对象的地址是否相等。

综上所述,原子引用能够保证你在修改对象引用时的线程安全性。

(2) 解决ABA问题

解决ABA问题,可以采用自旋锁+版本号来解决

自旋锁+版本(时间戳)比对

源码分析

原子类与自旋锁原理初探_第4张图片
原子类与自旋锁原理初探_第5张图片

使用示例

  public class TestAtomic {
     
    public static void main(String[] args) {
     
        // 自旋锁+版本号的原子类 构造函数的Stamp 1 代表版本号(或者说是时间戳)
        // 注意参数传入值类型的时候会自动装箱 int->Integer 如果Ref的值(第一个参数)设置过大 超出Integer指定范围(-128~127之间) Integer会在堆上new一块新的内存地址,导致比对不正确
        AtomicStampedReference<Integer> stampedReference = new AtomicStampedReference(100,1);

        new Thread(()->{
     
            //记录当前的num值
            int num=100;
            //比较并交换值
            stampedReference.compareAndSet(num,++num,1,2);
            //获取当前版本号:getStamp()
            int stamp = stampedReference.getStamp();
            if(num==101) {
     
                System.out.println("a=>将值更新为了101,"+"当前版本号为:"+stamp);
            }
            try {
     
                Thread.sleep(100);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            //比较并交换值
            stampedReference.compareAndSet(num,++num,2,3);
            //获取当前版本号:getStamp()
            stamp = stampedReference.getStamp();
            if(num==102) {
     
                System.out.println("b=>将值更新为了102,"+"当前版本号为:"+stamp);
            }
            try {
     
                Thread.sleep(100);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            //比较并交换值
            stampedReference.compareAndSet(num,++num,3,4);
            //获取当前版本号:getStamp()
            stamp = stampedReference.getStamp();
            if(num==103) {
     
                System.out.println("c=>将值更新为了103,"+"当前版本号为:"+stamp);
            }
        }).start();
    }
}

在这里插入图片描述
注意点,也就是当预期值或者说版本号是int类型,且AtomicStampedReference泛型指定为Integer的时候,要注意值的大小
原子类与自旋锁原理初探_第6张图片

4. 自旋锁

自旋锁本身是靠CAS算法实现的,与Lock和synchronized无关

CAS算法是对于并发操作共享数据的支持,在目录2中有更具体的说明

CAS算法的3个操作数

  1. 内存值 (V)
  2. 预估值 (A)
  3. 更新值 (B)
  • 也就是仅当V==A的时候,V=B,否则就不进行任何操作
  • 比较和替换是一步原子性操作,不能被其他线程抢用

通过以上两点特性实现的自旋锁

自己实现一个自旋锁

/**
 * 自己实现一个自旋锁 (原子引用+CAS)
 * @author ruoxi
 */
public class My_CAS_Lock {
     
    /**
     * 使用原子引用,指定泛型类型为Thread
     */
    static AtomicReference<Thread> atomicReference = new AtomicReference<>();
    /**
     * CAS算法实现自旋锁的加锁
     */
    public void myLock() {
     
        //获取当前线程
        Thread thread = Thread.currentThread();
        //CAS算法实现 自旋锁
        //预期值:thread=null  读取内存中的值:当前线程的引用 thread = this.thread
        //如果当前线程不是空,则不能获取锁(说明有线程拿到锁了),开始一直自旋
        while(!atomicReference.compareAndSet(null,thread)){
     
            try {
     
                //使线程每次自旋间隔为1毫秒
                TimeUnit.MILLISECONDS.sleep(1);
            } catch (InterruptedException e) {
     
                e.printStackTrace();
            }
            System.out.println(thread.getName()+"=>在等待解锁..自旋中..");
        }
        //加锁 (其实只是利用CAS算法将其他线程隔离了)
        System.out.println(thread.getName()+"拿到了锁");
    }
    /**
     * CAS算法实现自旋锁的解锁
     */
    public void unlock(){
     
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName()+"释放了锁");
        //将当前线程置换为空,也就是释放了锁
        atomicReference.compareAndSet(thread,null);
    }
    /**
    * 测试
    */
    public static void main(String[] args) {
     
        //实例化一个自己实现的自旋锁
        My_CAS_Lock lock = new My_CAS_Lock();
        //开启两个线程,都需要获取自旋锁才能执行
        for (int i = 0; i < 2; i++) {
     
            new Thread(()->{
     
                //上锁
                lock.myLock();
                try {
     
                    //让线程沉睡10毫秒再解锁
                    TimeUnit.MILLISECONDS.sleep(10);
                } catch (InterruptedException e) {
     
                    e.printStackTrace();
                }finally {
     
                    //解锁
                    lock.unlock();
                }
            },"线程"+(i+1)).start();
        }
    }
}

原子类与自旋锁原理初探_第7张图片

你可能感兴趣的:(java,多线程,并发编程,CAS,自旋锁,原子类,java)