1.什么是原子类
原子的大概意思就是不可分割,在程序中的表现形式为一个操作不可中断,即便是多线程的情况下也可以保证,其中在
Java
中就有java.util.concurrent.atomic
包,这个包用来存储原子类。
2.原子类的作用
原子类的作用与锁类似,都是为了在并发场景下保证线程安全,不过原子类相对于锁具有以下优势:
- 锁的粒度更细:原子变量可以把竞争范围缩小到变量级别,这是我们可以获得的最细粒度的情况了,通常锁的粒度都会大于原子变量。
- 效率较高:通常,使用原子类的效率会比使用锁的效率更高,但是高度竞争的情况除外。
3.原子类纵览
4.演示原子类
4.1 常用方法(以AtomicInteger为例)
- 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),这个方法也是
CAS
思想的体现。
4.2 用原子类与普通变量做对比
/**
* 描述: 演示 AtomicInteger 的基本用法,并且对比非原子类的线程安全问题,
* 使用了原子类之后,不需要加锁也可以保证线程安全。
*/
public class AtomicIntegerDemo1 implements Runnable {
private static final AtomicInteger atomicInteger = new AtomicInteger();
public void incrementAtomic() {
atomicInteger.getAndIncrement();
}
// 添加 volatile 关键字保证可见性的同时不保证原子性
private static volatile int basicCount = 0;
public void incrementBasic() {
basicCount++;
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
incrementAtomic();
incrementBasic();
}
}
public static void main(String[] args) throws InterruptedException {
AtomicIntegerDemo1 demo1 = new AtomicIntegerDemo1();
Thread t1 = new Thread(demo1);
Thread t2 = new Thread(demo1);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("原子类的结果是:" + atomicInteger.get());
System.out.println("普通变量的结果是:" + basicCount);
}
}
复制代码
运行结果:
4.3 使用原子数组
/**
* 描述: 演示原子数组的使用方法
*/
public class AtomicArrayDemo {
public static void main(String[] args) throws InterruptedException {
AtomicIntegerArray atomicIntegerArray =
new AtomicIntegerArray(1000);
Decrementer decrementer = new Decrementer(atomicIntegerArray);
Incrementer incrementer = new Incrementer(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++) {
threadsDecrementer[i].join();
threadsIncrementer[i].join();
}
for (int i = 0; i < atomicIntegerArray.length(); i++) {
if (atomicIntegerArray.get(i) != 0) {
System.out.println("发现了非0值" + 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);
}
}
}
复制代码
运行结果:
因为使用的是原子数组,所以无论运行多少次都不会出现非0的情况。4.4 Atomic引用在自旋锁的应用
AtomicReference
类的作用和AtomicInteger
并没有什么区别,AtomicInteger
可以让一个整数保证原子性,而AtomicReference
可以让一个对象保证原子性。因为对象中可以包含多个属性,所以AtomicReference
比AtomicInteger
功能要强一些。
/**
* 描述: 演示自旋锁
*/
public class SpinLock {
// 声明自旋锁
private AtomicReference<Thread> sign = new AtomicReference<>();
/**
* 加锁
*/
public void lock() {
Thread current = Thread.currentThread();
// 使用 while 循环加 CAS 操作实现自旋
// 希望没有线程持有锁,传入 null
// 希望更新的值是自己,传入 current
while (!sign.compareAndSet(null, current)) {
System.out.println(Thread.currentThread().getName() + "自旋获取失败,再次尝试");
}
}
/**
* 解锁
*/
public void unlock() {
Thread current = Thread.currentThread();
// 解锁首先要有锁,所以一次就可以解掉,不需要 while 循环
// 希望持有锁的线程是自己,传入 current
// 因为是解锁,所以要更新的值为 null
sign.compareAndSet(current, null);
}
public static void main(String[] args) {
SpinLock spinLock = new SpinLock();
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()
+ "开始尝试获取自旋锁");
spinLock.lock();
System.out.println(Thread.currentThread().getName()
+ "获取到了自旋锁");
try {
Thread.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
spinLock.unlock();
System.out.println(Thread.currentThread().getName()
+ "释放了自旋锁");
}
}
};
// 用两个线程执行任务,模拟争抢
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
thread2.start();
}
}
复制代码
4.5 把普通变量升级为原子变量
原子变量在保证线程安全的同时开销也要比普通变量大得多,因为需要维护内部的一些逻辑,所以如果在需要的时候将普通变量升级为原子变量的话,就可以大大的节省系统资源,提升系统执行效率,下面就来演示一下将普通变量升级为原子变量。
/**
* 描述: 演示 FieldUpdater 的用法
*/
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 将普通变量升级为原子变量
scoreUpdater.getAndIncrement(tom);
}
}
public static class Candidate {
volatile int score;
}
public static void main(String[] args) throws InterruptedException {
AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();
tom = new Candidate();
peter = new Candidate();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
t1.join();
t1.join();
System.out.println("普通的变量: " + peter.score);
System.out.println("升级后的变量: " + tom.score);
}
}
复制代码
运行结果:
4.5.1 使用属性更新器的注意事项
- 必须是
int
类型的字段,int
的包装类也不可以 - 必须添加
volatile
修饰 - 不能是
private
访问权限 - 不能添加
static
关键字
4.6 Adder 累加器
由于
long
的字节数比int
要多,所以在使用AtomicLong
时的效率要比AtomicInteger
要低一些,针对这个情况,在 Java 8 中引入了一个新的类Adder累加器,在高并发场景下LongAdder
的开销要比AtomicLong
效率要高,不过本质是以空间换时间。当竞争激烈的时候,LongAdder
把不同线程对应到不同的Cell
上进行修改,降低了冲突的概率,这也是多段锁的理念,从而提升了并发性。
4.6.1 演示 AtomicLong 与 LongAdder 的性能差别
- AtomicLong
/**
* 描述: 演示高并发场景下 LongAdder 要比 AtomicLong 要好。
*/
public class AtomicLongDemo {
public static void main(String[] args) throws InterruptedException {
AtomicLong counter = new AtomicLong(0);
ExecutorService executorService = Executors.newFixedThreadPool(20);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
executorService.submit(new Task(counter));
}
executorService.shutdown();
while (!executorService.isTerminated()) {
}
long endTime = System.currentTimeMillis();
System.out.println(counter.get());
System.out.println("AtomicLong 耗时为:" + (endTime - startTime) + " ms");
}
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();
}
}
}
}
复制代码
运行结果:
- LongAdder
/**
* 描述: 演示高并发场景下 LongAdder 要比 AtomicLong 要好。
*/
public class LongAdderDemo {
public static void main(String[] args) throws InterruptedException {
LongAdder counter = new LongAdder();
ExecutorService executorService = Executors.newFixedThreadPool(20);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
executorService.submit(new Task(counter));
}
executorService.shutdown();
while (!executorService.isTerminated()) {
}
long endTime = System.currentTimeMillis();
System.out.println(counter.sum());
System.out.println("LongAdder 耗时为:" + (endTime - startTime) + " ms");
}
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();
}
}
}
}
复制代码
运行结果:
4.6.2 剖析高速运转的原理
-
AtomicLong
在使用
AtomicLong
进行累加时,每个线程之间需要将使用共享内存进行通信,即线程执行操作时只能在工作内存中进行,然后将值刷新到主内存,在高并发场景下频繁的刷新和获取操作会带来一定的性能开销。 -
LongAdder
LongAdder
引入了分段累加的概念,在内部有一个base
变量和Cell[]
数组共同参与计数:- base变量:竞争不激烈,直接累加到该变量上。
- Cell数组:竞争激烈,各个线程分散累加到自己的槽
Cell[i]
中。
4.6.3 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;
}
复制代码
首先将负责计数的cells
赋值给as
,这样就可以通过as
来获取数值了,base
用于并发不激烈的情况下,这里使用了sum
进行统计。接下来是判断as
的是否为空,如果为空说明根本没有向Cell
中存储数,所以直接返回sum
(base)即可,如果用到了cell
就将它做遍历,并将值从中取出,并用sum
进行统计。
总结:在低争用下,AtomicLong
和LongAdder
这两个类具有相同的特性。但是在竞争激烈的情况下,LongAdder
的预期吞吐量要高得多,但是消耗的空间也多。
LongAdder
适合的场景是统计求和计数的场景,而且LongAdder
基本只提供add()
方法,而AtomicLong
还具有CAS
方法。
4.7 Accumulator 累加器
Accumulator
和Adder
非常相似,Accumulator
是一个更通用版的Adder
。
4.7.1 使用 LongAccumulator 累加器
/**
* 描述: 演示 LongAccumulator 的用法
*/
public class LongAccumulatorDemo {
public static void main(String[] args) {
LongAccumulator longAccumulator =
new LongAccumulator((x, y) -> x + y, 0);
ExecutorService executorService = Executors.newFixedThreadPool(8);
// 从0开始,从1加到9
IntStream.range(1, 10)
.forEach(i -> executorService.submit(() -> longAccumulator.accumulate(i)));
executorService.shutdown();
while (!executorService.isTerminated()) {
}
System.out.println(longAccumulator.getThenReset());
}
}
复制代码
运行结果:
参考链接:
慕课网之玩转Java并发工具,精通JUC,成为并发多面手