Java并发编程之原子操作类

什么是原子操作类

当更新一个变量的时候，多出现数据争用的时候可能出现所意想不到的情况。这时的一般策略是使用synchronized解决，因为synchronized能够保证多个线程不会同时更新该变量。然而，从jdk 5之后，提供了粒度更细、量级更轻，并且在多核处理器具有高性能的原子操作类。因为原子操作类把竞争的范围缩小到单个变量上，这可以算是粒度最细的情况了。

原子操作类相当于泛化的volatile变量，能够支持原子读取-修改-写操作。比如AtomicInteger表示一个int类型的数值，提供了get和set方法，这些volatile类型的变量在读取与写入上有着相同的内存语义。原子操作类共有13个类，在java.util.concurrent.atomic包下，可以分为四种类型的原子更新类：原子更新基本类型、原子更新数组类型、原子更新引用和原子更新属性。

下面介绍这各种原子操作类

1 原子更新基本类型：使用原子方式更新基本类型

AtomicBoolean：原子更新布尔变量
AtomicInteger：原子更新整型变量
AtomicLong：原子更新长整型变量
2 原子更新数组：通过原子更新数组里的某个元素

AtomicIntegerArray：原子更新整型数组的某个元素
AtomicLongArray：原子更新长整型数组的某个元素
AtomicReferenceArray：原子更新引用类型数组的某个元素
3 原子更新引用类型：更新引用类型

AtomicReference：原子更新引用类型
AtomicReferenceFieldUpdater：原子更新引用类型里的字段
AtomicMarkableReference：原子更新带有标记位的引用类型
4 原子更新字段：原子更新某个类的某个字段

AtomicIntegerFieldUpdater：原子更新整型字段
AtomicLongFieldUpdater：原子更新长整型字段
AtomicStampedReference：原子更新带有版本号的引用类型
我们接下来会通过对AtomicInteger的讲解来深入认识原子操作类

在单线程环境下，执行num++等操作时不会出现问题，那么，在多线程环境下是否还是跟单线程环境下一样安全呢？我们通过一段代码进行模拟。

public class Demo {
    
	private static int num = 0;
	
	public static void add() {
		num++;
	}
	
    public static void main(String[] args) {
		Thread[] myThread = new Thread[10];
		for(Thread thread : myThread) {
			thread = new Thread() {
				@Override
				public void run() {
					for(int i = 0;i < 1000;i++) {
						add();
					}
				}
			};
			thread.start();
		}
		
		while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(num);
    }
}

　　

我们进行三次测试，得出结果分别是

8400
8318
9856
在没有同步条件下，自增操作不具备原子性，在多线程环境下是不安全的。

既然我们上面的方法不安全，那该咋办呢，总不能坐以待毙吧？没事，我们有一件新武器，那就是AtomicInteger原子类型。把上面的代码改为使用AtomicInteger，让我们看看接下来会发生什么？

import java.util.concurrent.atomic.AtomicInteger;

public class Demo {
    
	public static AtomicInteger num = new AtomicInteger(0);
	
	public static void add() {
		num.incrementAndGet();
	}
	
    public static void main(String[] args) {
		Thread[] myThread = new Thread[10];
		for(Thread thread : myThread) {
			thread = new Thread() {
				@Override
				public void run() {
					for(int i = 0;i < 1000;i++) {
						add();
					}
				}
			};
			thread.start();
		}
		
		while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println(num);
    }
}

　　

根据测试，程序终于得出了正确结果10000了！感动！流泪！

在讲解AtomicInteger的实现原理之前，我们先来介绍一下非阻塞同步

同步，就是多线程并发访问共享数据时，保证共享数据在同一时刻只被一个或一些线程使用。同步可以分为阻塞同步和非阻塞同步两种。非阻塞同步对于阻塞同步而言主要解决了阻塞同步中线程阻塞和唤醒带来的性能问题，那什么叫做非阻塞同步呢？在并发环境下，某个线程对共享变量先进行操作，如果没有其他线程争用共享数据那操作就成功；如果存在数据的争用冲突，那就才去补偿措施，比如不断的重试机制，直到成功为止，因为这种乐观的并发策略不需要把线程挂起，也就把这种同步操作称为非阻塞同步（操作和冲突检测具备原子性）。在硬件指令集的发展驱动下，使得 “操作和冲突检测” 这种看起来需要多次操作的行为只需要一条处理器指令便可以完成，这些指令中就包括非常著名的CAS指令（Compare-And-Swap比较并交换）。

CAS指令

CAS，即我们常说的Compare and Swap（比较并交换）。他使用乐观锁技术，语义为“我认为V的值应该为A，如果是，那么将V的值更新为B，否则不修改并告诉V的值实际为多少”。当多个线程尝试使用CAS同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。CAS有3个操作数，内存值V，旧的预期值A，要修改的新值B。当且仅当预期值A和内存值V相同时，将内存值V修改为B，否则什么都不做。

懂得了CAS指令，再来看AtomicInteger.incrementAndGet()方法就变得简单了

    public final int incrementAndGet() {
        for (;;) {
            int current = get();
            int next = current + 1;
            if (compareAndSet(current, next))
                return next;
        }
    }

　　

incrementAndGet()方法在一个无限循环体内，不断尝试将一个比当前值大1的新值赋给自己，如果失败则说明在执行"获取-设置"操作的时已经被其它线程修改过了，于是便再次进入循环下一次操作，直到成功为止。

我们接着看compareAndSet方法的实现

    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

　　

我们可以观察到，compareAndSet()调用的就是Unsafe.compareAndSwapInt()方法，即Unsafe类的CAS操作。

AtomicInteger使用总结

AtomicInteger是在使用非阻塞算法实现并发控制，在一些高并发程序中非常适合

原文：https://blog.csdn.net/Geffin/article/details/90376150