浅谈原子类

浅谈原子类

什么是原子类，有什么作用？

1. 不可分割
2. 一个操作是不可中断的，即便是多线程的情况下也可以保证
3. urrent.atomic
4. 原子类的作用和锁类似，是为了保证并发情况下线程安全。不过原子类相比于锁，有一定的优势
5. 粒度更细: 原子变量可以把竞争范围缩小到变量级别，这是我门可以获得的最细粒度的情况了，通常锁的粒度都要大于原子变量的粒度
6. 效率更高: 通常，使用原子类的效率会比使用锁的效率更高，除了高度竞争的情况

6类原子类纵览

Atomic基本类型原子类，已 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

public class AtomicIntegerDemo1 implements Runnable{private static final AtomicInteger atomicAtomicInteger = new AtomicInteger();private static volatile int basicCount = 0;public void incrementAtomic() {AndIncrement();}public void incrementBasic() {basicCount++;}@Overridepublic void run() {for (int i = 0; i < 10000; i++) {incrementAtomic();incrementBasic();}}public static void main(String[] args) throws InterruptedException {AtomicIntegerDemo1 atomicIntegerDemo1 = new AtomicIntegerDemo1();Thread t1 = new Thread(atomicIntegerDemo1);Thread t2 = new Thread(atomicIntegerDemo1);t1.start();t2.start();t1.join();t2.join();System.out.println("原子类的结果: " + ());//20000System.out.println("普通变量的结果: " + basicCount);//少于20000}
}

Atomic*Array数组类型原子类

hreadstudy.atomics;import urrent.atomic.AtomicIntegerArray;@SuppressWarnings("all")
public class AtomicArrayDemo {public static void main(String[] args) {int len = 100;AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(len);Thread[] threadsIncrementer = new Thread[len];Thread[] threadsDecrementer = new Thread[len];Incrementer incrementer = new Incrementer(atomicIntegerArray);Decrementer decrementer = new Decrementer(atomicIntegerArray);for (int i = 0; i < len; i++) {threadsIncrementer[i] = new Thread(incrementer);threadsDecrementer[i] = new Thread(decrementer);}for (int i = 0; i < len; i++) {threadsIncrementer[i].start();threadsDecrementer[i].start();}while (Thread.activeCount() > 2);for (int i = 0; i < len; i++) {if ((i) != 0) {System.out.println("发现了错误 " + i);}}System.out.println("运行结束");}
}
class Decrementer implements Runnable {private AtomicIntegerArray array;public Decrementer(AtomicIntegerArray array) {this.array = array;}@Overridepublic void run() {for (int i = 0; i < array.length(); i++) {AndDecrement(i);}}
}
class Incrementer implements Runnable {private AtomicIntegerArray array;public Incrementer(AtomicIntegerArray array) {this.array = array;}@Overridepublic void run() {for (int i = 0; i < array.length(); i++) {AndIncrement(i);}}
}

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 (!signpareAndSet(null, current)) {}}public void unlock() {Thread current = Thread.currentThread();signpareAndSet(current, null);}public static void main(String[] args) {SpinLock spinLock = new SpinLock();Runnable runnable = () -> {System.out.println(Thread.currentThread().getName() + "开始尝试获取自旋锁");spinLock.lock();System.out.println(Thread.currentThread().getName() + "获取到了自旋锁");try {Thread.sleep(1000L);} catch (InterruptedException e) {e.printStackTrace();} finally {System.out.println(Thread.currentThread().getName() + "释放自旋锁");spinLock.unlock();}};Thread t1 = new Thread(runnable);Thread t2 = new Thread(runnable);t1.start();t2.start();}
}

把普通变量升级为原子类:用 AtomicIntegerFieldUpdater升级原有变量

◆ AtomicIntegerFieldUpdater对普通变量进行升级

◆使用场景:偶尔需要一个原子 get-set操作

public class AtomicIntegerFiledUpdaterDemo implements Runnable{static Candidate tom;static Candidate peter;public static AtomicIntegerFieldUpdater<Candidate> scoreUpdater &#wUpdater(Candidate.class, "score");@Overridepublic void run() {for (int i = 0; i < 10000; i++) {peter.score++;AndIncrement(tom);}}public static class Candidate {volatile int score;}public static void main(String[] args) throws InterruptedException {tom = new Candidate();peter = new Candidate();AtomicIntegerFiledUpdaterDemo demo = new AtomicIntegerFiledUpdaterDemo();Thread t1 = new Thread(demo);Thread t2 = new Thread(demo);t1.start();t2.start();t1.join();t2.join();System.out.println("普通变量: " + peter.score);System.out.println("升级变量: " + tom.score);}
}

AtomicIntegerFieldUpdater注意点

◆可见范围

◆不支持 static

Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: java.lang.IllegalArgumentExceptionat java.base/jdk.internal.misc.Unsafe.objectFieldOffset0(Native Method)at java.base/jdk.internal.misc.Unsafe.objectFieldOffset(Unsafe.java:955)at java.base/urrent.atomic.AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl.<init>(AtomicIntegerFieldUpdater.java:434)at java.base/urrent.wUpdater(AtomicIntegerFieldUpdater.java:94)hreadstudy.atomics.AtomicIntegerFiledUpdaterDemo.<clinit>(AtomicIntegerFiledUpdaterDemo.java:12)

◆volatile声明

Exception in thread "main" java.lang.ExceptionInInitializerError
Caused by: java.lang.IllegalArgumentException: Must be volatile typeat java.base/urrent.atomic.AtomicIntegerFieldUpdater$AtomicIntegerFieldUpdaterImpl.<init>(AtomicIntegerFieldUpdater.java:420)at java.base/urrent.wUpdater(AtomicIntegerFieldUpdater.java:94)hreadstudy.atomics.AtomicIntegerFiledUpdaterDemo.<clinit>(AtomicIntegerFiledUpdaterDemo.java:12)

Adder累加器

◆是Java8引入的，相对是比较新的一个类

◆高并发下 LongAdder比 AtomicLong效率高，不过本质是空间换时间

◆竟争激烈的时候， LongAdder把不同线程对应到不同的cell上进行修改，降低了冲突的概率，是多段锁的理念，提高了并发性

◆代码演示

public class AtomicLongDemo {public static void main(String[] args) {test();}public static void test() {new Thread(() -> testAtomicLong()).start();new Thread(() -> testLongAddr()).start();}public static void testAtomicLong() {ExecutorService service = wFixedThreadPool(20);AtomicLong counter = new AtomicLong(0);long startTime = System.currentTimeMillis();for (int i = 0; i < 10000; i++) {service.submit(new TaskAtomicLong(counter));}service.shutdown();while (!service.isTerminated());long endTime = System.currentTimeMillis();System.out.println("AtomicLong result: " + () + ", time: " + (endTime - startTime) + " ms");}public static void testLongAddr() {ExecutorService service = wFixedThreadPool(20);LongAdder counter = new LongAdder();long startTime = System.currentTimeMillis();for (int i = 0; i < 10000; i++) {service.submit(new TaskLongAddr(counter));}service.shutdown();while (!service.isTerminated());long endTime = System.currentTimeMillis();System.out.println("LongAddr result: " + counter.sum() + ", time: " + (endTime - startTime) + " ms");}private static class TaskAtomicLong implements Runnable {private AtomicLong counter;public TaskAtomicLong(AtomicLong counter) {unter = counter;}@Overridepublic void run() {for (int i = 0; i < 1000000; i++) {counter.incrementAndGet();}}}private static class TaskLongAddr implements Runnable {private LongAdder counter;public TaskLongAddr(LongAdder counter) {unter = counter;}@Overridepublic void run() {for (int i = 0; i < 10000; i++) {counter.increment();}}}}

◆这里演示多线程情况下 AtomicLong的性能，有20个线程对同个 AtomicLong累加

◆由于竞争很激烈，每一次加法，AtomicLong都要flush和 refresh，导致很耗费资源。

比较LongAdder和AtomicLong的原理：

1. 在内部，这个 LongAdder的实现原理和 AtomicLong是有不同的， AtomicLong的实现原理是，每一次加法都需要做同步，所以在高并发的时候会导致冲突比较多，也就降低了效率
2. 而此时的 LongAdder，每个线程会有自己的一个计数器，仅用来在自己线程内计数，这样一来就不会和其他线程的计数器干扰，他们之间并不存在竞争关系所以在加和的过程中，根本不需要同步机制，也不需要flush和 Refresh，这里也没有—个公共的counter来给所有线程统一计数

LongAddr为啥快？？：

1. LongAdder引入了分段累加的概念，内部有一个base变量和一个Cell[]数组共同参与计数
2. base变量:竞争不激烈，直接累加到该变量上
3. cell[]数组:竞争激烈，各个线程分散累加到自己的槽Cell[]中

public long sum() {Cell[] cs = cells;long sum = base;if (cs != null) {for (Cell c : cs)if (c != null)sum += c.value;}return sum;
}

对比 AtomicLong和 LongAdder的使用场景：

1. 在低争用下， AtomicLong和 LongAdder，这两个类具有相似的特征。但是在竞争激烈的情况下， LongAdder的预期吞吐量要高得多，但要消耗更多的空间
2. LongAdder适合的场景是统计求和计数的场景，而且LongAdder基本只提供了add方法，而 AtomicLong还具有Cas方法

Accumulator累加器

Accumulator和 Adder非常相似， Accumulator就是一个更通用版本的 Adder

适合大量计算和并行计算， 无先后逻辑顺序.

计算1+2 +3 +...+8+9的和

LongAccumulator accumulator = new LongAccumulator(Long::sum, 0);
ExecutorService service = wFixedThreadPool(8);
IntStream.range(1, 10).forEach( i -> service.submit(() -> accumulator.accumulate(i)));
service.shutdown();
while (!service.isTerminated());
System.out.ThenReset());

计算9!

public static void main(String[] args) {LongAccumulator accumulator = new LongAccumulator((x ,y) -> x * y, 1);ExecutorService service = wFixedThreadPool(8);IntStream.range(1, 10).forEach( i -> service.submit(() -> accumulator.accumulate(i)));service.shutdown();while (!service.isTerminated());System.out.ThenReset());
}