Atomic包

一、原子类

1. 一个操作是不可中断的，即便多线程情况下也可以保证；
2. java.util.concurrent.atomic包中的类都是具有原子性的；
3. 原子类相比于锁的优势：
   • 粒度更细，变量级别
   • 通常效率更高，高度竞争下效率降低

二、6类原子类

三、Atomic基本类型原子类

AtomicInteger就是对Integer的封装，利用CAS实现。

常用方法

public final int get()

获取当前的值

public final int getAndSet(int newValue)

获取当前的值，并设置新的值

public final int getAndIncrement()

获取当前的值，并自增
这里的自增相比于a++，是具有原子性的，不可中断。

public final int getAndDecrement()

获取当前的值，并自减

public final int getAndAdd(int delta)

获取当前的值，并加上预期的值
原子的a+=b

boolean compareAndSet(int expect,int update)

如果当前数值等于预期值（expect），则以原子方式将update设置为输入值

四、Atomic*Array数组类型原子类

初始化：初始化指定长度，数组中的每个元素都是具有原子性的。

AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);

操作与AtomicInteger类似，但是在调用时需要指定相应下标：

atomicIntegerArray.getAndDecrement(5);//对下标为5的元素--

五、AtomicReference引用类型原子类

Atomic*Reference可以让一个对象保证原子性。

compareAndSet方法很关键，可以原子地设置对象的值。

六、普通变量升级具有原子功能

AtomicIntegerFieldUpdater可以对普通变量进行升级。

1.使用场景：

偶尔需要一个原子的get-set操作。一开始只定义为普通变量，可以减小资源的占用。

2.使用方法

假设有一个静态内部类Candidate，拥有int型的属性score。

    public static class Candidate{
        volatile int score;
    }
    static Candidate tom;

那么初始化一个AtomicIntegerFieldUpdater类的方法就是：

    public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater 
            = AtomicIntegerFieldUpdater.newUpdater(Candidate.class,"score");
    //对score字段进行升级

如果要使用，则在Updater中调用对应的方法并且传入实例。例如要对tom的score进行+1：

scoreUpdater.getAndIncrement(tom);
//在读取时和普通变量相同
System.out.println(tom.score);

3.注意点

1. 可见范围：原理是利用了反射，如果变量是private（不可见）就不能使用；
2. 不能用于静态变量。

七、Adder累加器

1.Adder累加器

Adder是Java 8引入的，高并发下LongAdder比AtomicLong效率高，本质是空间换时间。

在竞争激烈的时候，LongAdder把不同线程对应到不同的Cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性。

（1）AtomicLong高并发下的缺点

假如有16个线程对同一个AtomicLong累加，提交一万份任务，每一个任务都对AtomicLong实例进行10000次累加。观察最终消耗的时间：

public class AtomicLongDemo {
    public static void main(String[] args) {
        AtomicLong counter = new AtomicLong(0);
        ExecutorService executorService = Executors.newFixedThreadPool(16);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        counter.getAndIncrement();
                    }
                }
            });
        }
        executorService.shutdown();
        while(!executorService.isTerminated()){
        }
        long end = System.currentTimeMillis();
        System.out.println("数值为"+counter.get()+"\n耗时："+(end-start)+"ms");
    }
}
//数值为100000000
//耗时：1228ms

将其中的counter改为LongAdder类，然后观察结果：

可以看出效率提升很多。

（2）Adder效率高的原因

AtomicLong在每次加法时，都会将修改后的值刷新回主内存（flush），在读取数据时又会从主内存中读取数据到本地内存（refresh）。

LongAdder不需要保证本地内存中数据和主内存中同步，每个线程有一个自己的计数器，不会和其他线程干扰。

LongAdder引入了分段累加概念，内部有一个base变量和一个Cell[]数组共同参与计数。

• base变量：竞争不激烈，直接累加到变量上
• Cell[]数组：竞争激烈时，各个线程分散累加到自己的槽Cell[i]中

通过观察sum()的源码：

    public long sum() {
        Cell[] as = cells; Cell a;
        long sum = base;
        if (as != null) {
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        return sum;
    }

可以看到，在sum()方法中，将base和Cell[]中的值累加起来，作为最终的结果。
但是由于这个方法是不加锁的，也就是说在计算的过程中base或Cell中的值还是会改变的，所以不一定精确。

（3）LongAdder与AtomicLong对比

LongAdder适用于统计求和计数的场景，而且LongAdder只提供了add方法，也就是只能加减，而AtomicLong还具有CAS方法。

八、Accumulator累加器

Accumulator与Adder类似，但是更加通用。

    public static void main(String[] args) {
        LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);
        accumulator.accumulate(1);
        accumulator.accumulate(2);
        System.out.println(accumulator.getThenReset());
    }

相比于Adder，Accumulator可以自定义规则。对于每次累计进来的值，可以采取任何的措施。比如：

• 取最大值(x,y) -> Math.max(x,y)
• 相乘(x,y) ->x*y
• 等等

相比于for循环，Accumulator可以利用线程池进行并行计算。在使用线程池时，计算不能和顺序相关。