atomic包【一刻也不能分割】
1、什么是原子类,有什么作用?
java.util.concurrent.atomic
特点:不可分割,一个操作是不可中断的,即便是多线程的情况下也可以保证。
作用:原子类的作用和锁类似,是为了保证并发情况下的线程安全。
不过原子类相比于锁,有一定的优势:
- 粒度更细:原子操作可以把竞争范围缩小到变量级别,这是我们可以获得的最细粒度的情况了,通常锁的粒度都要大于原子变量的粒度;
- 效率更高:通常,使用原子类的效率会比使用锁的效率更高,除了高度竞争的情况。
2、Atomic*基本类型原子类
2.1 AtomicInteger:原子类
get()
:获取当前的值getAndSet(int newValue)
:获取当前的值,并设置新的值getAndIncrement()
:获取当前的值,并自增getAndDecrement()
:获取当前的值,并自减getAndAdd(int delta)
:获取当前的值,并加上预期值compareAndSet(int expect, int update)
:如果输入的值等于预期值,则以原子方式将该值设置为输入值(update)
public class AtomicIntegerDemo1 implements Runnable {
private static final AtomicInteger atomicInteger = new AtomicInteger();
private void incrementAtomic() {
//如果我们仅仅是对某一个数值需要保证线程安全的话,使用atomicInteger是非常合适的
atomicInteger.getAndIncrement();
}
private void decrementAtomic() {
atomicInteger.getAndDecrement();
}
private void getAndAdd() {
atomicInteger.getAndAdd(10);
}
private static volatile int basicCount = 0;
private synchronized 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();
//decrementAtomic();
getAndAdd();
incrementBasic();
}
}
}
3、Atomic*Array数组类型原子类
如果说在做账务系统或者财务管理的时候,经常会有并发的修改,这种修改需要保证原子性,可以利用AtomicIntegerArray
来保障线程安全。
public class AtomicArrayDemo {
public static void main(String[] args) {
AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(1000);
Incrementer incrementer = new Incrementer(atomicIntegerArray);
Decrementr decrementr = new Decrementr(atomicIntegerArray);
Thread[] threadsIncrementer = new Thread[100];
Thread[] threadsDecrementer = new Thread[100];
for (int i = 0; i < 100; i++) {
threadsDecrementer[i] = new Thread(decrementr);
threadsIncrementer[i] = new Thread(incrementer);
threadsDecrementer[i].start();
threadsIncrementer[i].start();
}
//Thread.sleep(10000);
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++) {
System.out.println(atomicIntegerArray.get(i));
if (atomicIntegerArray.get(i) != 0) {
System.out.println("发现了错误" + i);
}
}
System.out.println("运行结束");
}
}
class Decrementr implements Runnable {
private AtomicIntegerArray array;
public Decrementr(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); //自增
}
}
}
4、Atomic*Reference引用类型原子类
AtomicReference:AtomicReference
类的作用,与AtomicInteger
并没有本质区别。AtomicInteger
可以让一个整数保证原子性,而AtomicReference
可以让一个对象保证原子性,当然,AtomicReference
的功能明显比AtomicInteger
强,因为一个对象里可以包含很多属性。用法和AtomicInteger
类似。
public class SpinLock {
private AtomicReference<Thread> sign = new AtomicReference<>();
//锁住
public void lock() {
//拿到当前线程的引用
Thread current = Thread.currentThread();
//死循环,直到原子引用被赋为当前线程才会停止
while (!sign.compareAndSet(null, current)) { //加锁
System.out.println("自旋获取失败,再次尝试");
}
}
//解锁
public void unlock() {
Thread current = Thread.currentThread();
//把当前线程置为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();
}
}
5、把普通变量升级为原子类,用AtomicIntegerFieldUpdater升级原有变量
AtomicIntegerFieldUpdaterDemo.java
AtomicIntegerFieldUpdater
对普通变量进行升级,适用场景:
- 如果一个类不是我们编写的,我们没有权利去修改它,此时可以使用
AtomicIntegerFieldUpdater
; - 偶尔需要一个原子get-set操作;
AtomicIntegerFieldUpdater
注意点:
a、 所能修改的是具有一个可见范围的;
b、不支持被static修饰的变量。
6、Adder累加器(*)
java8中引入的;高并发下LongAdder比AtomicLong效率高,不过本质是空间换时间;最大的好处就是在竞争激烈的时候,LongAdder
把不同线程对应到不同的Cell上进行修改,降低了冲突的概率,是多段锁的理念,提高了并发性;
6.1、代码演示
这里演示多线程的情况下,AtomicLong
的性能,有20个线程同时对一个AtomicLong
累加;由于竞争很激烈,每一次加法,都要flush和refresh,导致很耗费资源。
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();
//service.isTerminated() 判断线程池是否把任务都执行完毕
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++) {
//循环1w次,自增
counter.incrementAndGet();
}
}
}
}
运行结果:
100000000
AtomicLong耗时:1897
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();
//service.isTerminated() 判断线程池是否把任务都执行完毕
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++) {
//循环1w次,自增
counter.increment();
}
}
}
}
运行结果:
100000000
LongAdder耗时:205
6.2、LongAdder带来的改进和原理
- 在内部,这个
LongAdder
的实现原理和刚才的AtomicLong
是有不同的,刚才的AtomicLong
的实现原理是:每一次加法都需要做同步,所以在高并发的时候会导致冲突比较多,也就降低了效率;而LongAdder
不需要在每一次计算的时候都同步,而是说只有在最后求和的时候才需要把最后整个的值进行汇总。 - 而此时的
LongAdder
,每个线程会有自己的一个计数器,仅用来在自己线程内计数,这样一来就不会和其他线程的计数器干扰; - 如图中所示,第一个线程的计数器数值也就是ctr‘,为1的时候,可能线程2的计数器ctr’‘已经是3了,它们之间并不存在竞争关系,所以在加和的过程中,根本不需要同步机制,也不需要刚才的flush和refresh。这里也没有一个公共的counter来给所有线程统一计数。
- LongAdder引入了分段累加的概念,内部有一个base变量和一个Cell[]数组共同参与计数:
a、base变量:竞争不激烈,直接累加到该变量上
b、Cell[]数组:竞争激烈,各个线程分散累加自己的槽Cell[i]中
c、sum源码分析
6.3、对比AtomicLong和LongAdder
在低争用下,AtomicLong
和LongAdder
这两个类具有相似的特征。但是在竞争激烈的情况下,LongAdder
的预期吞吐量要高得多,但要消耗更多的空间。LongAdder
适合的场景是统计求和的场景,而且LongAdder
基本只提供了add方法,而AtomicLong
还具有cas方法;
7、Accumulator累加器
Accumulator
和Adder
非常相似,Accumulator就是一个更通用版本的Adder。
public class LongAccumulatorDemo {
public static void main(String[] args) {
// 计算初始值和下一个值
/*LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);
accumulator.accumulate(1);
System.out.println(accumulator.getThenReset());*/
//1、计算1+2+3...+9
/*LongAccumulator accumulator = new LongAccumulator((x, y) -> x + y, 0);
ExecutorService executor = Executors.newFixedThreadPool(8);
//实现1-9,每一次提交一个计算
IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
executor.shutdown();
while (!executor.isTerminated()) {
}
System.out.println(accumulator.getThenReset());*/
//2、计算最大值
LongAccumulator accumulator = new LongAccumulator((x, y) -> Math.max(x, y), 0);
ExecutorService executor = Executors.newFixedThreadPool(8);
//实现1-9,每一次提交一个计算
IntStream.range(1, 10).forEach(i -> executor.submit(() -> accumulator.accumulate(i)));
executor.shutdown();
while (!executor.isTerminated()) {
}
System.out.println(accumulator.getThenReset());
}
}
适用场景:
- 适合于需要大量计算并且需要并行计算的场景,如果不需要并行计算使用for循环确实可以解决问题;
但是使用了Accumulator之后可以利用多核同时计算,大大提高计算效率; - 计算的顺序不能有要求,线程1可能在线程5之后执行也可能之前执行。
下一章: 第十九章 CAS原理