本文深入讲解Java中的原子类，包括其基本概念、作用及不同类型的原子类应用实例。重点介绍了AtomicInteger、AtomicArray、AtomicReference等原子类的特性和使用方法，并探讨了LongAdder在高并发场景下的优势。
什么是原子类，有什么作用
① 不可分割
② 一个操作是不可中断的，即便是多线程的情况下也可以保证
③ java.util.concurrent.atomic
④ 原子类的作用和锁类似，是为了保证并发情况下的线程安全。不过原子类相对于锁有一点的优势
-
粒度更细：原子变量可以把竞争范围缩小到变量级别，这是我们可以获得的最细的粒度的情况了，通常锁的粒度都要大于原子变量的粒度
-
效率更高：通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况
6类原子类纵览
Atomic*基本类型原子类，以AtomicInteger为例
1.AtomicInteger方法
2.常用方法
public final int get()//获取当前值
public final int getAndSet(int newValue)//获取当前值，并设置新的值
pubilic final int getAndIncrement()//获取当前值，并自增
pubilic 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(){//synchronized保证线程安全
basicCount++;
}
public static void main(String[] args) throws InterruptedException {
AtomicIntegerDemo1 r = new AtomicIntegerDemo1();
Thread thread1 = new Thread(r);
Thread thread2 = new Thread(r);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("原子类的结果是 "+atomicInteger.get());
System.out.println("普通变量的结果是 "+basicCount);
}
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
incrementAtomic();
incrementBasic();
}
}
}
Atomic*Arrray数组类型原子类
/**
* 演示原子数组的使用方法
*/
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++) {
threadsIncrementer[i] = new Thread(incrementer);
threadsDecrementer[i] = new Thread(decrementer);
threadsIncrementer[i].start();
threadsDecrementer[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(atomicIntegerArray.get(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);
}
}
}
Atomic*Reference引用类型原子类
自旋锁使用
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();
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();
}
}
把普通变量升级为原子类
用AtomicIntegerFieldUpdate升级原有变量
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;//不支持private、static
}
public static void main(String[] args) throws InterruptedException {
tom = new Candidate();
peter = new Candidate();
AtomicIntegerFieldUpdaterDemo r = new AtomicIntegerFieldUpdaterDemo();
Thread thread1 = new Thread(r);
Thread thread2 = new Thread(r);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
System.out.println("普通的变量：" + peter.score);
System.out.println("升级后的结果：" + tom.score);
}
}
注意点：
① 可见范围：变量不能为private
② 不支持static
Adder累加器
① java8引入的，相比较是一个比较新的类
② 高并发下LogAdder比AtomicLog效率高，不过本质是空间换时间
③ 竞争激烈的时候，LongAdder把不同线程对应到不同的Cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性
④ LongAdder适合的场景是统计求和计数的场景，而且LongAdder基本只提供了add方法，而AtomicLong还具有cas方法
演示多线程下AtomicLong的性能，有20个线程对同一个AtomicLong累加（由于竞争很激烈，每一次加法，都要flush和refresh,导致很耗费资源）
/**
* 演示高并发场景下，LongAdder比AtomicLong性能好
*/
@SuppressWarnings("all")
public class AtomicLongDemo {
public static void main(String[] args) throws InterruptedException {
AtomicLong counter = new AtomicLong();
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("AtomicLon耗时：" + (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();
}
}
}
}
LongAdder演示
@SuppressWarnings("all")
public class AtomicAdderDemo {
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();
}
}
}
}
累加结果耗时显示
LongAdder改进和原理：
① 在内部，这个LongAdder的实现原理和刚才的AtomicLong是不同的，刚才的AtomicLong的实现原理是，每一次加法都需要做同步，所以在高并发的时候会导致冲突比较多，也就降低了效率
② 而此时的LongAdder,每个线程都有一个计数器，仅用来在自己的线程内计算，这样一来就不会和其他线程的计数器干扰
③ 如上图，第一个线程的计数器的数值，也就是ctr’,为1的时候，可能线程2的计数器ctr’’的数值已经是3了，他们之间并不存在竞争关系，所以在加和的过程中，根本不需要同步机制，也不需要刚才的flush和reflush。这里没有一个公共的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;
}
Accumulator累加器
public class LongAccumulatorDemo {
public static void main(String[] args) {
LongAccumulator accumulator = new LongAccumulator((x,y)->x+y,0);
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());
}
}
使用场景：
① 适用于需要大量计算，并且需要并行计算的场景，如果不需要并行计算，可用for循环解决问题，用了Accumulator累加器可利用多核同时计算，提供效率
② 计算的顺序不能成为瓶颈，线程1可能在线程5之后运行，也可能在之前运行，不影响最终结果
扫一扫
1895
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
