并发编程-JUC之Atomic

概述：

　　早期的JDK版本中，如果要并发的对Integer、Long、Double之类的Java原始类型或引用类型进行操作，一般都需要通过锁来控制并发，以防止数据不一致。JUC-Atomic原子类位于java.util.concurrent.atomic包下。该包提供了许多Java原始/引用类型的映射类。如AtomicInteger、AtomicLong、AtomicBoolean，这些类可以通过一种“无锁算法”，线程安全的操作Integer、Long、Boolean等原始类型。

---

包中类分为五种：

　　基本类型：

• AtomicBoolean：布尔型原子类
• AtomicInteger：整型原子类
• AtomicLong：长整型原子类

　　数组：

• AtomicIntegerArray：整形数组原子类
• AtomicLongArray：长整形数组原子类
• AtomicReferenceArray：引用类型数组原子类

　　引用类型：

• AtomicReference：引用类型原子类
• AtomicStampedRerence：原子更新引用类型里的字段原子类
• AtomicMarkableReference：原子更新带有标记位的引用类型

　　对象的属性：

• AtomicIntegerFieldUpdater：原子更新整形字段的更新器
• AtomicLongFieldUpdater：原子更新长整形字段的更新器
• AtomicReferenceFieldUpdater：原子更新带有版本号的引用类型。该类将整数值与引用关联起来，可用于解决原子的更新数据和数据的版本号，可以解决使用 CAS 进行原子更新时可能出现的 ABA 问题

　　本文不会详细介绍这几种类型的api及使用，只是列出Atomic的实现原理，及比较重点的类

---

基本类型原子类：　

• AtomicBoolean：布尔型原子类
• AtomicInteger：整型原子类
• AtomicLong：长整型原子类

　　这几个类的共同特点是都提供单个变量的原子方式访问和更新功能。以AtomicLong为代表，进行介绍。

我们使用AtomicLong来演示之前的线程不安全的例子：

/**
 * 并发测试代码
 */
@ThreadSafe
public class AtomicExample2 {
    //请求总数
    public static int clientTotal = 5000;
    //同时并发执行的线程数
    public static int threadTotal = 200;
    //变成了AtomicLong类型
    public static AtomicLong count = new AtomicLong(0);
    public static void main(String[] args) throws InterruptedException {
        //创建线程池
        ExecutorService executorService = Executors.newCachedThreadPool();
        //定义信号量
        final Semaphore semaphore = new Semaphore(threadTotal);
        //定义计数器 闭锁
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal; i++) {
            executorService.execute(() ->{
                try {
                    semaphore.acquire();
                    add();
                    //释放
                    semaphore.release();
                } catch (Exception e) {
                    System.out.println("exception:"+e.getMessage());
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count:{}"+count.get());
    }
    private static void add(){
        count.incrementAndGet();//先做增加再获取当前值
        //count.getAndIncrement();先获取当前值再做增加
    }
}

当使用AtomicLong去执行自增操作时，得出的最终结果count就是5000。数次运行情况下结果一致。不会带来线程不安全的情况。那我们来看看AtomicLong是如何保证线程安全的呢。

我们看看incrementAndGet方法，看看AtomicLong如何实现单个变量的原子方式更新。Unsafe是CAS的核心类，AtomicLong是基于CAS实现的。此处就介绍AtomicLong，AtomicBoolean、AtomicInteger、AtomicReference与之相似，就不一一介绍

private static final Unsafe unsafe = Unsafe.getUnsafe();

public final long incrementAndGet() {
    return unsafe.getAndAddLong(this, valueOffset, 1L) + 1L;
}

incrementAndGet方法实际上是调用Unsafe类的方法来执行操作，我们进入Unsafe里看看具体的getAndAddLong是如何实现原子方式更新的。

public final long getAndAddLong(Object var1, long var2, long var4) {
    long var6;
    do {
        var6 = this.getLongVolatile(var1, var2);
    } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
    return var6;
}

我们来解析一下这个方法，var1为当前调用这个方法的对象，var2是当前值，假如执行的2+1=3的操作，那么var4就是1。var6是调用底层方法获得底层当前值。假设没有其他线程来处理count，那么var6就是var2。此处使用了一个do while循环。compareAndSwapLong方法是native的，代表是java底层的方法。也是遵循CAS算法的api。compareAndSwap，比较并交换。在getAndAddLong的while判断中，该方法实现的是：

　　对于var1这个对象，如果当前值var2和底层值var6相同的话，就更新为后面的操作结果值。当我们执行更新结果时，可能被其他线程修改，因此此处判断当前值与期望值相同时才允许更新。否则重新取出当前的底层值，和当前count的值再做比较。保证当前值与底层值完全一致时才进行结果更新，以此保证线程安全。这也是Atomic使用CAS原理实现的机制。底层值是主内存中的值，当前值是源自于工作内存。

　　由于该方法的逻辑是采用自旋的方式不断更新目标值，直到更新成功，在并发量较低的环境下，线程冲突较少，自旋次数不会很多。但是在高并发情况下，N个线程同时进行自旋操作，会出现大量失败并不断自旋的情况，此时的AtomicLong的自旋会成为瓶颈，因此为了解决高并发环境下的AtomicLong的自旋瓶颈问题，引入了LongAdder。

---

 LongAdder：

　　AtomicLong中有个内部变量value保存着实际的long值，所有的操作都是针对该变量进行。也就是说，高并发环境下，value变量其实是一个热点，也就是N个线程竞争一个热点。LongAdder的基本思路就是分散热点，将value值分散到一个数组中，不同线程会命中到数组的不同槽中，各个线程只对自己槽中的那个值进行CAS操作，这样热点就被分散了，冲突的概率就小很多。如果要获取真正的long值，只要将各个槽中的变量值累加返回。

　　低并发、一般的业务场景下AtomicLong是足够了。如果并发量很多，存在大量写多读少的情况，那LongAdder可能更合适。

---

 AtomicBoolean：

　　针对该类我们主要研究compareAndSet函数

public final boolean compareAndSet(boolean expect, boolean update) {
    int e = expect ? 1 : 0;
    int u = update ? 1 : 0;
    return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}

　　该函数实现的功能是高并发情况下只有一个线程能访问这个属性值，常用于初始化一次的功能中。

private static AtomicBoolean initialized = new AtomicBoolean(false);
    public void init()
    {
       if( initialized.compareAndSet(false, true) )//如果为false，更新为true
       {
           // 初始化操作代码....
       }
    }

　　各原子类api及使用demo，可以参考：https://github.com/Snailclimb/JavaGuide/blob/master/Java%E7%9B%B8%E5%85%B3/Multithread/Atomic.md

　　主要是掌握CAS算法的设计思想，了解原子类如何保证原子操作。

 

转载于:https://www.cnblogs.com/zhangbLearn/p/9922790.html