Java并发15：原子类

开启掘金成长之旅！这是我参与「掘金日新计划 · 12 月更文挑战」的第15天，点击查看活动详情

学习MOOC视频记录的笔记

1.什么是原子类，有什么作用？

• 不可分割

• 一个操作是不可中断的，即便是多线程的情况下也可以保证

• java.util.concurrent.atomic

• 原子类的作用和锁类似，是为了保证并发情况下线程安全。不过原子类相比于锁，有一定的优势：

  • 粒度更细：原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的最细粒度的情况了，通常锁的粒度都要大于原子变量的粒度
  • 效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况

2.6类原子类纵览

3.Atomic*基本类型原子类，以AtomicInteger为例

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

常用方法：

• public final int get() // 获取当前的值
• public final int getAndSet(int newValue) // 获取当前的值，并设置新的值
• public final int getAndIncrement() // 获取当前的值，并自增
• public final int getAndDecrement() // 获取当前的值，并自减
• public final int getAndAdd(int delta) // 获取当前的值，并加上预期的值
• boolean compareAndSet(int expect, int update) // 如果当前的数值等于预期值，则以原子方式将该值设置为输入值update

/**
* 演示AtomicInteger的基本用法，对比非原子类的线程安全问题，使用了原子类之后，不需要加锁，也可以保证线程安全
*/
public class AtomicIntegerDemo1 implements Runnable {
    private static final AtomicInteger atomicInteger = new AtomicInteger();
 
    public void incrementAtomic() {
        atomicInteger.getAndIncrement();
    }
 
    private static volatile int basicCount = 0;
 
    // 加锁才是线程安全的
    public synchronized void incrementBasic() {
        basicCount++;
    }
 
    // public void incrementBasic() {
    //     basicCount++;
    // }
 
    public static void main(String[] args) throws InterruptedException {
        AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("原子类的结果: " + atomicInteger.get());
        System.out.println("普通变量的结果: " + basicCount);
    }
 
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            incrementAtomic();
            incrementBasic();
        }
    }
}

运行结果：

原子类的结果: 20000
普通变量的结果: 17620

4.Atomic*Array数组类型原子类

/**
* 演示原子数组的使用方法
*/
public class AtomicArrayDemo {
    public static void main(String[] args) {
        AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);
        Incrementer incrementer = new Incrementer(atomicIntegerArray);
        Decrementer decrementer = new Decrementer(atomicIntegerArray);
 
        Thread[] threadsIncrementer = new Thread[100];
        Thread[] threadsDecrementer = new Thread[100];
        for (int i = 0; i < 100; i++) {
            threadsDecrementer[i] = new Thread(decrementer);
            threadsIncrementer[i] = new Thread(incrementer);
            threadsDecrementer[i].start();
            threadsIncrementer[i].start();
        }
 
        for (int i = 0; i < 100; i++) {
            try {
                threadsDecrementer[i].join();
                threadsIncrementer[i].join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
 
        for (int i = 0; i < atomicIntegerArray.length(); i++) {
            if (atomicIntegerArray.get(i) != 0) {
                System.out.println("发现了错误" + i);
            }
        }
        System.out.println("运行结束");
    }
}
 
class Decrementer implements Runnable {
 
    private AtomicIntegerArray array;
 
    public Decrementer(AtomicIntegerArray array) {
        this.array = array;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndDecrement(i);
        }
    }
}
 
class Incrementer implements Runnable {
 
    private AtomicIntegerArray array;
 
    public Incrementer(AtomicIntegerArray array) {
        this.array = array;
    }
 
    @Override
    public void run() {
        for (int i = 0; i < array.length(); i++) {
            array.getAndIncrement(i);
        }
    }
}

5.Atomic*Reference引用类型原子类

AtomicReference：AtomicReference类的作用，和AtomicInteger并没有本质区别，AtomicInteger可以让一个整数保证原子性，而AtomicReference可以让一个对象保证原子性，当然，AtomicReference的功能明显比AtomicInteger强，因为一个对象里可以包含很多属性。用法和AtomicInteger类似。

参考SpinLock代码

6.把普通变量升级为原子类：用AtomicIntegerFieldUpdater升级原有变量

• AtomicIntegerFieldUpdater 对普通变量进行升级
• 使用场景：偶尔需要一个原子 get-set 操作

/**
* 演示 AtomicIntegerFieldUpdaterDemo 的用法
*/
public class AtomicIntegerFieldUpdaterDemo implements Runnable {
 
    static Candidate tom;
    static Candidate peter;
 
    public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater = AtomicIntegerFieldUpdater.newUpdater(Candidate.class, "score");
 
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            peter.score++;
            scoreUpdater.getAndIncrement(tom);
        }
    }
 
    public static class Candidate {
        volatile int score;
    }
 
    public static void main(String[] args) throws InterruptedException {
        tom = new Candidate();
        peter = new Candidate();
        AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();
        Thread t1 = new Thread(r);
        Thread t2 = new Thread(r);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("普通变量: " + peter.score);
        System.out.println("升级后结果: " + tom.score);
    }
}

运行结果：

普通变量: 17704
升级后结果: 20000

• 可见范围：因为是通过反射
• 不支持static

7.Adder累加器

• 是Java8引入的，相对是比较新的一个类
• 高并发下 LongAdder 比 AtomicLong 效率高，不过本质是空间换时间
• 竞争激烈的时候，LongAdder 把不同线程对应到不同的 Cell 上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性

代码演示

/**
* 演示高并发场景下，LongAdder比AtomicLong性能好
*/
public class AtomicLongDemo {
    public static void main(String[] args) throws InterruptedException {
        AtomicLong counter = new AtomicLong(0);
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            service.submit(new Task(counter));
        }
        service.shutdown();
        while (!service.isTerminated()) {
 
        }
        long end = System.currentTimeMillis();
        System.out.println(counter.get());
        System.out.println("AtomicLong耗时: " + (end - start));
    }
 
    private static class Task implements Runnable {
        private AtomicLong counter;
 
        public Task(AtomicLong counter) {
            this.counter = counter;
        }
 
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                counter.incrementAndGet();
            }
        }
    }
}

100000000
AtomicLong耗时: 1311

public class LongAdderDemo {
    public static void main(String[] args) throws InterruptedException {
        LongAdder counter = new LongAdder();
        ExecutorService service = Executors.newFixedThreadPool(20);
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            service.submit(new Task(counter));
        }
        service.shutdown();
        while (!service.isTerminated()) {
 
        }
        long end = System.currentTimeMillis();
        System.out.println(counter.sum());
        System.out.println("LongAdder耗时: " + (end - start));
    }
 
    private static class Task implements Runnable {
        private LongAdder counter;
 
        public Task(LongAdder counter) {
            this.counter = counter;
        }
 
        @Override
        public void run() {
            for (int i = 0; i < 10000; i++) {
                counter.increment();
            }
        }
    }
}

100000000
LongAdder耗时: 69

• 这里演示多线程情况下 AtomicLong 的性能，有16个线程对同一个 AtomicLong 累加
• 由于竞争很激烈，每一次加法，都要 flush 和 refresh，导致很耗费资源

AtomicLong一直保持不同线程之间的数据同步。

LongAddr 不需要保证保证不同线程之间的数据始终一致。

• 在内部，这个LongAdder的实现原理和刚才的AtomicLong是有不同的，刚才的AtomicLong的实现原理是，每一次加法都需要做同步，所以在高并发的时候会导致冲突比较多，也就降低了效率
• 而此时的LongAdder，每个线程会有自己的一个计数器，仅用来在自己线程内计数，这样一来就不会和其他线程的计数器干扰
• 如图中所示，第一个线程的计数器数值，也就是ctr'为1的时候，可能线程2的计数器ctr''的数值已经是3了，他们之间并不存在竞争关系，所以在加和的过程中，根本不需要同步机制，也不需要刚才的flush和refresh。这里也没有一个公共的counter来给所有线程统一计数

• 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;
}

对比AtomicLong和LongAdder：

• 在低争用下，AtomicLong和LongAdder这两个类具有相似的特征。但是在竞争激烈的情况下，LongAdder的预期吞吐量要高得多，但要消耗更多的空间
• LongAdder适合的场景是统计求和计数的场景，而且LongAdder基本只提供了add方法，而AtomicLong还具有cas方法

8.Accumulator累加器

Accumulator和Adder非常相似，Accumulator就是一个更通用版本的Adder

适合需要大量并行计算的场景，计算顺序不能有要求

public class LongAccumulatorDemo {
    public static void main(String[] args) {
        // LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);
        // LongAccumulator accumulator = new LongAccumulator((x, y) -> Math.max(x, y), 0);
        LongAccumulator accumulator = new LongAccumulator((x, y) -> x * y, 1);
        // accumulator.accumulate(1);
        // accumulator.accumulate(2);
        ExecutorService executor = Executors.newFixedThreadPool(8);
        IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
        executor.shutdown();
        while (!executor.isTerminated()) {
 
        }
        System.out.println(accumulator.getThenReset());
    }
}