1、什么是原子类？什么情况下使用原子类？

java 1.5引进原子类，具体在java.util.concurrent.atomic包下，atomic包里面一共提供了13个类，分为4种类型，分别是：原子更新基本类型，原子更新数组，原子更新引用，原子更新属性。原子类也是java实现同步的一套解决方案。

既然已经有了synchronized关键字和lock，为什么还要引入原子类呢？或者什么场景下使用原子类更好呢？

在很多时候，我们需要的仅仅是一个简单的、高效的、线程安全的递增或者递减方案，这个方案一般需要满足以下要求：

1、 简单：操作简单，底层实现简单

2、 高效：占用资源少，操作速度快

3、 安全：在高并发和多线程环境下要保证数据的正确性

对于是需要简单的递增或者递减的需求场景，使用synchronized关键字和lock固然可以实现，但代码写的会略显冗余，且性能会有影响，此时用原子类更加方便。

面试的时候可以举meterService添加监控项的例子，walGet、walAcl，起一个周期线程池调用sdk往CMC提交数据，参考举周写的。

2、原子类如何使用

上面介绍了原子类有4大类，这里以原子更新基本类型中的AtomicInteger类为例，介绍通用的API接口和使用方法。

首先是几个常用的API：

// 以原子方式将给定值与当前值相加，可用于线程中的计数使用，（返回更新的值）。
int addAndGet（int delta）

// 以原子方式将给定值与当前值相加，可用于线程中的计数使用，（返回以前的值）
int getAndAdd（int delta）

// 以原子方式将当前值加 1（返回更新的值）
int incrementAndGet()

// 以原子方式将当前值加 1（返回以前的值）
int getAndIncrement() 

// 以原子方式设置为给定值（返回旧值）
int getAndSet(int newValue)

// 以原子方式将当前值减 1（返回更新的值）
int decrementAndGet() ：

// 以原子方式将当前值减 1（返回以前的值）
int getAndDecrement()

// 获取当前值
get()

还是举那个同步问题的经典例子，定义一个临界变量val，起10个异步线程，每个线程都是对这个临界变量进行1000次自增操作，如下：

package Atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ClassName AtomicWrongDemo
 * @Description TODO
 * @Auther Jerry
 * @Date 2020/3/22 - 22:40
 * @Version 1.0
 */

public class AtomicWrongDemo {
    private int val = 0;

    public static void main(String[] args) {
        // 初始化实例
        AtomicWrongDemo atomicWrongDemo = new AtomicWrongDemo();

        for (int i = 0; i < 10; ++i)
        {
            new Thread(atomicWrongDemo::increase).start();
        }

        // 让主线程休眠5秒，保证前面起的10个异步线程都执行完毕
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println(atomicWrongDemo.getVal());
    }

    private void increase()
    {
        for (int i = 0; i < 1000; ++i)
        {
            ++this.val;
        }
    }

    private int getVal()
    {
        return this.val;
    }
}

运行结果有时为我们期望的10000，有时候比10000少，比如9408，出现比10000少的结果是因为自增操作++i不是原子操作，出现了竞争，需要对临界变量做同步处理。

使用synchronized关键字和lock固然可以实现，但这里只是对临界变量val++时做同步处理，有种高射炮打蚊子的感觉，且加锁后势必会对性能有所印象，这种场景正是我们使用Atomic类的场景，如下：

package Atomic;

import java.util.concurrent.atomic.AtomicInteger;

/**
 * @ClassName AtomicDemo
 * @Description TODO
 * @Auther Jerry
 * @Date 2020/3/22 - 22:31
 * @Version 1.0
 */

public class AtomicDemo {
    private AtomicInteger val = new AtomicInteger();

    public static void main(String[] args) {
        // 初始化实例
        AtomicDemo atomicDemo = new AtomicDemo();

        for (int i = 0; i < 10; ++i)
        {
            new Thread(atomicDemo::increase).start();
        }

        // 让主线程休眠5秒，保证前面起的10个异步线程都执行完毕
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e)
        {
            e.printStackTrace();
        }
        System.out.println(atomicDemo.getVal().toString());
    }

    private void increase()
    {
        for (int i = 0; i < 1000; ++i)
        {
            this.val.incrementAndGet();
        }
    }

    private AtomicInteger getVal()
    {
        return this.val;
    }
}

这里我们使用了AtomicInterger类的increamentAndGet方法，以原子方式将当前值加 1（返回更新的值），结果自然是每次运行都打印10000，可以看到代码写起来很简洁，很轻量级。

这里的API估计我用的时候还得再看看，因为用的也不多，所以知道怎么用API，到时候再查一下用就行。

参考文章

• https://zhuanlan.zhihu.com/p/115345089