03-java并发编程之atomic

上篇博客讲到了锁,通过我们对程序加锁,我们在高并发下也可以达到我们想要的预期
效果,同时我们也知道加锁的话,会造成很多线程需要被等待拿锁效率不是很高(其实很高了)。那有没有更好的办法了?今天我们就来学习下,java著名的原子操作包java.util.concurrent.atomic,简称Atomic

Atomic体系

在这里插入图片描述
可以简单归纳为
在这里插入图片描述

新增jdk8:LongAdder
首先我们来说下AtomicInteger:
AtomicInteger是对int类型的一个封装,提供原子性的访问和更新操作。常见的api有
java.util.concurrent.atomic.AtomicInteger#incrementAndGet 原子自增1
java.util.concurrent.atomic.AtomicInteger#decrementAndGet原子自减1
java.util.concurrent.atomic.AtomicInteger#addAndGet原子在当前值加上给定的值。
java.util.concurrent.atomic.AtomicInteger#get返回当前最新的值

使用场景: 并发统计、订单号

原理:Atomic实现都是CAS

在这里插入图片描述

CAS算法:
CAS的全称是Compare And Swap 即比较交换,其算法核心思想如下
函数:CAS(V,E,N) 参数:V表示要更新的变量 E预期值 N新值

  • CAS有3个操作数,内存值V,旧的预期值A,要修改的新值B。当且仅当预期值A和内存值V相同时,将内存值V修改为B,否则什么都不做
  • 如果V值等于E值,则将V的值设为N。若V值和E值不同,则说明已经有其他线程做了更新,则当前线程什么都不做。通俗的理解就是CAS操作需要我们提供一个期望值,当期望值与当前线程的变量值相同时,说明还没线程修改该值,当前线程可以进行修改,也就是执行CAS操作,但如果期望值与当前线程不符,则说明该值已被其他线程修改,此时不执行更新操作,但可以选择重新读取该变量再尝试再次修改该变量,也可以放弃操作
CAS原理解析
  • 用CPU的CAS指令,同时借助JNI来完成Java的非阻塞算法,其它原子操作都是利用类似的特性完成的。 在 java.util.concurrent 下面的源码中,Atomic, ReentrantLock 都使用了Unsafe类中的方法来保证并发的安全性。
    +CAS操作是原子性的,所以多线程并发使用CAS更新数据时,可以不使用锁,JDK中大量使用了CAS来更新数据而防止加锁来保持原子更新。
  • CAS 操作包含三个操作数 :内存偏移量位置(V)、预期原值(A)和新值(B)。 如果内存位置的值与预期原值相匹配,那么处理器会自动将该位置值更新为新值 。否则,处理器不做任何操作
CAS的ABA问题(了解即可)

对于Java中的锁,Synchronized 是基于jvm的,lock是基于代码的,而CAS是基于cpu实现的。
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200213145038491.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2JhbnB1,size_16,color_FFFFFF,t_70
初始化值int i=10,线程A将i值修改为20,线程B将i值修改为10,线程C去读这个i值的时候,误以为值并未修改过(值相同,但是经历了两次修改)。

如下代码,就发生了ABA的问题。

public class AtomicIntegerABAExample {
  private static AtomicInteger atomicInt = new AtomicInteger(100);
  
  public static void main(String[] args) throws InterruptedException {
    Thread intT1 = new Thread(new Runnable() {
      @Override
      public void run() {
        atomicInt.compareAndSet(100, 101);
        atomicInt.compareAndSet(101, 100);
      }
    });

    Thread intT2 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
        boolean c3 = atomicInt.compareAndSet(100, 101);
        System.out.println(c3); // true
        System.out.println(atomicInt.get()); // 101
      }
    });
    intT1.start();
    intT2.start();
    intT1.join();
    intT2.join();
  }
}

解决思路就是使用版本号。在变量前面追加版本号,每次变量更新的时候把版本号+1,那么A->B->A 就会变成1A->2B->3A。从JDK1.5 开始,JDK的Atomic包里提供了一个类Atomic包里提供了一个AtomicStampedReference来解决ABA问题,

public boolean compareAndSet(
V expectedReference, // 预期引用
V newReference, // 更新后的引用
int expectedStamp, // 预期标志
int newStamp // 更新后的标志
)

compareAndSet方法的作用首先检查当前引用是否等于预期 引用,并且检查当前标志是否 等于预期标志,如果全部相等,则以原子方式将该引用和该标志的值设置为给定的更新值

上述代码如何避免ABA?

public class AtomicStampesABAExample {
  // 0 相当于一个标识符,
  private static AtomicStampedReference atomicStampedRef = new AtomicStampedReference(100,0);

  public static void main(String[] args) throws InterruptedException {
    Thread refT1 = new Thread(new Runnable() {
      @Override
      public void run() {
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
        }
        atomicStampedRef.compareAndSet(100, 101, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
        atomicStampedRef.compareAndSet(101, 100, atomicStampedRef.getStamp(), atomicStampedRef.getStamp() + 1);
      }
    });

    Thread refT2 = new Thread(new Runnable() {
      @Override
      public void run() {
        int stamp = atomicStampedRef.getStamp();
        try {
          TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
        }
        boolean c3 = atomicStampedRef.compareAndSet(100, 101, stamp, stamp + 1);
        System.out.println(c3); // false
      }
    });
    refT1.start();
    refT2.start();

  }
}
线程安全
  • 就是当多线程访问时,采用了加锁的机制;即当一个线程访问该类的某个数据时,会对这个数据进行保护,其他线程不能对其访问,直到该线程读取完之后,其他线程才可以使用。防止出现数据不一致或者数据被污染的情况
  • 线程不安全:就是不提供数据访问时的数据保护,多个线程能够同时操作某个数据,从而出现数据不一致或者数据污染的情况。
  • 对于线程不安全的问题,一般会使用synchronized、lock加锁;ava的原子操作Atomic包下的类和volatile修饰的变量也能保证线程安全
悲观锁

总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程)。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

乐观锁

总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

两种锁的使用场景
  • 从上面对乐观锁与悲观的介绍,我们知道两种锁各有优缺点,不可认为一种好于另一种,像乐观锁适用于写比较少的情况下(多读场景),即冲突真的很少发生的时候,这样可以省去了锁的开销,加大了系统的整个吞吐量。但如果是多写的情况,一般会经常产生冲突,这就会导致上层应用会不断的进行retry,这样反倒是降低了性能,所以一般多写的场景下用悲观锁就比较合适。
  • 简单的来说CAS适用于写比较少的情况下(多读场景,冲突一般较少),synchronized适用于写比较多的情况下(多写场景,冲突一般较多)
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值