java 1.5引进原子类,具体在java.util.concurrent.atomic包下,atomic包里面一共提供了13个类,分为4种类型,分别是:原子更新基本类型,原子更新数组,原子更新引用,原子更新属性。原子类也是java实现同步的一套解决方案。
既然已经有了synchronized关键字和lock,为什么还要引入原子类呢?或者什么场景下使用原子类更好呢?
在很多时候,我们需要的仅仅是一个简单的、高效的、线程安全的递增或者递减方案,这个方案一般需要满足以下要求:
1、 简单:操作简单,底层实现简单
2、 高效:占用资源少,操作速度快
3、 安全:在高并发和多线程环境下要保证数据的正确性
对于是需要简单的递增或者递减的需求场景,使用synchronized关键字和lock固然可以实现,但代码写的会略显冗余,且性能会有影响,此时用原子类更加方便。
面试的时候可以举meterService添加监控项的例子,walGet、walAcl,起一个周期线程池调用sdk往CMC提交数据,参考举周写的。
上面介绍了原子类有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,到时候再查一下用就行。