J.U.C 系列之Atomic原子类

时间:2023-12-19 21:01:26

一 什么是原子类?

所谓原子类必然是具有原子性的类,原子性操作--原子操作,百度百科中给的定义如下

"原子操作(atomic operation)是不需要synchronized",这是Java多线程编程的老生常谈了。所谓原子操作是指不会被线程调度机制打断的操作;这种操作一旦开始,就一直运行到结束,中间不会有任何 context switch (切[1]  换到另一个线程)。

顾名思义,原子类就是一个一旦被执行就不能中断的类。

二 为什么需要原子类?

在看为什么需要原子类之前,我们看看普通Number类,在处理问题时可能存在的问题,这里我们通过Integer来演示

public class Main {

    private static Integer sum = 0;

    public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(new Task()).start();
} Thread.yield();
System.out.println(sum); } static class Task implements Runnable {
@Override
public void run() {
for(int i = 0;i<100;i++){
sum++;
}
}
}
}

这段代码意思是开20个线程,每个线程对sum自加100次,理论上应该最后输出2000;但是事实上每次都是小于2000;

这是听说过volatile关键字的小伙伴可能会说,使用volatile来修饰sum,好,我们继续试验

public class Main {

    private static volatile Integer sum = 0;

    public static void main(String[] args) {
for (int i = 0; i < 20; i++) {
new Thread(new Task()).start();
} Thread.yield();
System.out.println(sum); } static class Task implements Runnable {
@Override
public void run() {
for(int i = 0;i<100;i++){
sum++;
}
}
}
}

这是试验五次的输出

1766,1616,1859,1980,1800

还是都是小于2000,这是怎么回事,这里先提一下,volatile只能保证单个操作的原子性,而sum++,包括三个操作

sum = getSum()  //读取sum

temp = sum +1;  //sum+1,赋给临时变量

sum =  setSum(temp)      //将sum写回

因此,即使是volatile也无法保证sum++的原子性,volatile只能保证单个操作的原子性,而++操作是复合操作,volatile变量会在后续章节详细讨论;

那么,在Atomic未出现之前,是如何处理i++在多线程环境下的线程安全问题,主要是通过Synchronize加锁来处理,处理过程复杂,性能低

JDK5.0之后出现的Java.util.concurrent.Atomic包中为我们提供了13中原子类,来保证单个原子变量复合操作的原子性。下面我们通过AtomicInteger的使用来认识一下原子类

三 原子类示例详解

AtomicInteger 字段

   // setup to use Unsafe.compareAndSwapInt for updates
   //这里, unsafe是java提供的获得对对象内存地址访问的类,注释已经清楚的写出了,它的作用就是在更新操作时提供“比较并替换”的作用。实际上就是AtomicInteger中的一个工具。
private static final Unsafe unsafe = Unsafe.getUnsafe();
   //valueOffset是用来记录value本身在内存的便宜地址的,这个记录,也主要是为了在更新操作在内存中找到value的位置,方便比较。
private static final long valueOffset;
   //value是用来存储整数的时间变量,这里被声明为volatile,就是为了保证在更新操作时,当前线程可以拿到value最新的值(并发环境下,value可能已经被其他线程更新了)。
private volatile int value;

AtomicInteger 构造方法

 /**
* Creates a new AtomicInteger with the given initial value.
*
* @param initialValue the initial value
*/
public AtomicInteger(int initialValue) {
value = initialValue;
} /**
* Creates a new AtomicInteger with initial value {@code 0}.
*/
public AtomicInteger() {
}

AtomicInteger 并发安全实现

那么AtomicInteger是如何实现多线程的自增操作的线程安全的呢?核心思想就是CAS自旋;CAS:Compare And Swap 比较并交换。自旋:通过循环知道预期值和内存之相同,进行CAS操作,AtomicInteger的自增如下所示

       public final int incrementAndGet() {
for (;;) {
//这里可以拿到value的最新内存值
int current = get();
int next = current + 1;
if (compareAndSet(current, next))
return next;
}
} public final boolean compareAndSet(int expect, int update) {
//使用unsafe的native方法,实现高效的硬件级别CAS
return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
}

AtomicInteger 其他常用方法

  /**
* 返回旧值,然后自增1
*
* @return the previous value
*/
public final int getAndIncrement() {
return unsafe.getAndAddInt(this, valueOffset, 1);
} /**
* 返回旧值,然后自减1
*
* @return the previous value
*/
public final int getAndDecrement() {
return unsafe.getAndAddInt(this, valueOffset, -1);
} /**
* 返回旧值,然后 旧值+delta
*
* @param delta the value to add
* @return the previous value
*/
public final int getAndAdd(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta);
} /**
* 先进行自增,返回自增后的值
*
* @return the updated value
*/
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
} /**
* 先进行自减,然后返回自减后的值
*
* @return the updated value
*/
public final int decrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, -1) - 1;
} /**
*先在原值上加delta,再返回加之后的值
*
* @param delta the value to add
* @return the updated value
*/
public final int addAndGet(int delta) {
return unsafe.getAndAddInt(this, valueOffset, delta) + delta;
}

注:其他Atomic类类似,不一一介绍;

四 Atomic 存在的问题

    》 长时间自旋,导致CPU和资源的占用

  》 只能保证单个原子变量的多线程安全操作,当然可以将多个变量封装成一个类,通过原子引用类型实现

  》 ABA问题;使用AtomicStampedReference 原子更新带有版本号的引用类型解决