Java多线程之Atomic：原子变量与原子类
Atomic简介
Atomic包是java.util.concurrent下的另一个专门为线程安全设计的Java包，包含多个原子操作类这个包里面提供了一组原子变量类。
其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)。可以对基本数据、数组中的基本数据、对类中的基本数据进行操作。原子变量类相当于一种泛化的volatile变量，能够支持原子的和有条件的读-改-写操作。
传统锁的问题
我们先来看一个例子：计数器（Counter），采用Java里比较方便的锁机制synchronized关键字，初步的代码如下：
class Counter {
private int value;
public synchronized int getValue() {
return value;
}
public synchronized int increment() {
return ++value;
}
public synchronized int decrement() {
return --value;
}
}
其实像这样的锁机制，满足基本的需求是没有问题的了，但是有的时候我们的需求并非这么简单，我们需要更有效，更加灵活的机制，synchronized关键字是基于阻塞的锁机制，也就是说当一个线程拥有锁的时候，访问同一资源的其它线程需要等待，直到该线程释放锁，这里会有些问题：首先，如果被阻塞的线程优先级很高很重要怎么办？其次，如果获得锁的线程一直不释放锁怎么办？（这种情况是非常糟糕的）。还有一种情况，如果有大量的线程来竞争资源，那CPU将会花费大量的时间和资源来处理这些竞争（事实上CPU的主要工作并非这些），同时，还有可能出现一些例如死锁之类的情况，最后，其实锁机制是一种比较粗糙，粒度比较大的机制，相对于像计数器这样的需求有点儿过于笨重，因此，对于这种需求我们期待一种更合适、更高效的线程安全机制，于是CAS诞生了。
传送门：CAS
Atomic
java.util.concurrent.atomic中的类可以分成4组：
- 标量类（Scalar）：AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference
- 数组类：AtomicIntegerArray，AtomicLongArray，AtomicReferenceArray
- 更新器类：AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater
- 复合变量类：AtomicMarkableReference，AtomicStampedReference
基础数据型
第一组AtomicBoolean，AtomicInteger，AtomicLong，AtomicReference这四种基本类型用来处理布尔，整数，长整数，对象四种数据，其内部实现不是简单的使用synchronized，而是一个更为高效的方式CAS (compare and swap) + volatile和native方法，从而避免了synchronized的高开销，执行效率大为提升。我们来看个例子，与我们平时i++所对应的原子操作为：getAndIncrement()
package com.company.atomics;
/*
* 使用原子变量类定义一个计数器
* 该计数器在整个程序中都能使用，并且在所有的地方都可以使用这个计数器，
* 这个计数器可以设计为单例
* */
import java.util.concurrent.atomic.AtomicLong;
public class Indicator {
//构造方法私有化
private Indicator(){}
//定义一个私有的本类静态的对象
private static final Indicator INSTANCE=new Indicator();
//提供一个公共静态方法返回唯一实例
public static Indicator getInstance(){
return INSTANCE;
}
//使用原子变量类保存请求总数，成功数，失败数
private final AtomicLong requestCount=new AtomicLong(0);
private final AtomicLong successCount=new AtomicLong(0);
private final AtomicLong failureCount=new AtomicLong(0);
//有新的请求
public void requestProcessReceive(){
requestCount.incrementAndGet();
}
//处理成功
public void requestProcessSuccess(){
successCount.incrementAndGet();
}
//处理失败
public void requestProcessFailur(){
failureCount.incrementAndGet();
}
//查看总数，
public long getRequestCount(){
return requestCount.get();
}
//查看成功数
public long getSuccessCount(){
return successCount.get();
}
//查看失败数
public long getFailurCount(){
return failureCount.get();
}
}
结果测试：
package com.company.atomics;
import java.util.Random;
public class IndicatorTest {
public static void main(String[] args) {
//通过线程模拟请求
for (int i = 0; i < 10000; i++) {
new Thread(new Runnable() {
@Override
public void run() {
//每个线程就是一个请求，请求总数要+1
Indicator.getInstance().requestProcessReceive();
int num=new Random().nextInt();
if (num%2==0){ //处理成功
Indicator.getInstance().requestProcessSuccess();
}else{ //处理失败
Indicator.getInstance().requestProcessFailur();
}
}
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Indicator.getInstance().getRequestCount());//总数
System.out.println(Indicator.getInstance().getSuccessCount());//成功数
System.out.println(Indicator.getInstance().getFailurCount());//失败数
}
}
常用方法
-
构造函数（两个构造函数）
- 默认的构造函数：初始化的数据分别是false，0，0，null
- 带参构造函数：参数为初始化的数据
-
set( )和get( )方法：可以原子地设定和获取atomic的数据。类似于volatile，保证数据会在主存中设置或读取
-
void set()和void lazySet()：set设置为给定值，直接修改原始值；lazySet延时设置变量值，这个等价于set()方法，但是由于字段是volatile类型的，因此次字段的修改会比普通字段（非volatile字段）有稍微的性能延时（尽管可以忽略），所以如果不是想立即读取设置的新值，允许在“后台”修改值，那么此方法就很有用。
-
getAndSet( )方法
-
原子的将变量设定为新数据，同时返回先前的旧数据
-
其本质是get( )操作，然后做set( )操作。尽管这2个操作都是atomic，但是他们合并在一起的时候，就不是atomic。在Java的源程序的级别上，如果不依赖synchronized的机制来完成这个工作，是不可能的。只有依靠native方法才可以。
public final int getAndSet(int newValue) { for (;;) { int current = get(); if (compareAndSet(current, newValue)) return current; } }
-
-
compareAndSet( ) 和weakCompareAndSet( )方法
这两个方法都是conditional modifier方法。接收2个参数，一个是期望数据(expected)，一个是新数据(new)，如果atomic里面的数据和期望数据一 致，则将新数据设定给atomic的数据，返回true，表明成功；否则就不设定，并返回false。JSR规范中说：以原子方式读取和有条件地写入变量但不 创建任何 happen-before 排序，因此不提供与除
weakCompareAndSet目标外任何变量以前或后续读取或写入操作有关的任何保证。大意就是说调用weakCompareAndSet时并不能保证不存在happen- before的发生（也就是可能存在指令重排序导致此操作失败）。但是从Java源码来看，其实此方法并没有实现JSR规范的要求，最后效果和 compareAndSet是等效的，都调用了unsafe.compareAndSwapInt()完成操作。public final boolean compareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); } public final boolean weakCompareAndSet(int expect, int update) { return unsafe.compareAndSwapInt(this, valueOffset, expect, update); } -
对于 AtomicInteger、AtomicLong还提供了一些特别的方法。
getAndIncrement( )：以原子方式将当前值加 1，相当于线程安全的i++操作。
incrementAndGet( )：以原子方式将当前值加 1， 相当于线程安全的++i操作。
getAndDecrement( )：以原子方式将当前值减 1， 相当于线程安全的i--操作。
decrementAndGet ( )：以原子方式将当前值减 1，相当于线程安全的--i操作。
addAndGet( )： 以原子方式将给定值与当前值相加， 实际上就是等于线程安全的i =i+delta操作。
getAndAdd( )：以原子方式将给定值与当前值相加， 相当于线程安全的t=i;i+=delta;return t;操作。
以实现一些加法，减法原子操作。(注意 --i、++i不是原子操作，其中包含有3个操作步骤：第一步，读取i；第二步，加1或减1；第三步：写回内存)
数组型
AtomicIntegerArray，AtomicLongArray还有AtomicReferenceArray类进一步扩展了原子操作，对这些类型的数组提供了支持。这些类在为其数组元素提供 volatile 访问语义方面也引人注目，这对于普通数组来说是不受支持的。
他们内部并不是像AtomicInteger一样维持一个valatile变量，而是全部由native方法实现，如下
AtomicIntegerArray的实现片断：
private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final int base = unsafe.arrayBaseOffset(int[].class);
private static final int scale = unsafe.arrayIndexScale(int[].class);
private final int[] array;
public final int get(int i) {
return unsafe.getIntVolatile(array, rawIndex(i));
}
public final void set(int i, int newValue) {
unsafe.putIntVolatile(array, rawIndex(i), newValue);
}
基本使用示例：
public class AtomicIntegerArrayTest {
public static void main(String[] args) {
//创建一个指定长度的原子数组
AtomicIntegerArray atomicIntegerArray=new AtomicIntegerArray(10);
System.out.println(atomicIntegerArray);//[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
//返回指定位置的元素
System.out.println(atomicIntegerArray.get(0));//0
System.out.println(atomicIntegerArray.get(1));//0
//设置指定位置的元素
atomicIntegerArray.set(0,10);
//先获取指定位置的值在设置
System.out.println(atomicIntegerArray.getAndSet(1,11));//0
//把数组元素加上某个值
System.out.println(atomicIntegerArray.addAndGet(0,22));//32
System.out.println(atomicIntegerArray.getAndAdd(1,33));//11
System.out.println(atomicIntegerArray);//[32, 44, 0, 0, 0, 0, 0, 0, 0, 0]
//CAS操作,如果0位置的值是32，就将其值修改为222
System.out.println(atomicIntegerArray.compareAndSet(0,32,222));//返回ture
//先自增在返回
System.out.println(atomicIntegerArray.incrementAndGet(0));//223
//先返回再自减
System.out.println(atomicIntegerArray.getAndIncrement(1));//44
System.out.println(atomicIntegerArray);//[223, 45, 0, 0, 0, 0, 0, 0, 0, 0]
//先自减再返回
System.out.println(atomicIntegerArray.decrementAndGet(2));//-1
//先返回再自减
System.out.println(atomicIntegerArray.getAndDecrement(3));//0
System.out.println(atomicIntegerArray);//[223, 45, -1, -1, 0, 0, 0, 0, 0, 0]
}
}
import java.util.concurrent.atomic.AtomicIntegerArray;
public class AtomicIntegerArrayTest01 {
//定义一个原子数组
static AtomicIntegerArray atomicIntegerArray = new AtomicIntegerArray(10);
public static void main(String[] args) {
//定义线程数组
Thread[] threads=new Thread[10];
//给线程数组赋值
for (int i = 0; i < threads.length; i++) {
threads[i]=new addThread();
}
//开启子线程
for (Thread thread:threads
) {
thread.start();
}
//在主线程中查看自增完后原子数组中各个元素的值，主线程中需要在所有子线程都执行完后查看
//把所有的子线程合并到当前主线程中
for (Thread thread:threads
) {
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(atomicIntegerArray)
}
//定义一个线程类，在线程类中修改原子数组
static class addThread extends Thread{
@Override
public void run() {
//把数组元素的每个元素自增1000次
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < atomicIntegerArray.length() ; j++) {
atomicIntegerArray.getAndIncrement(i%atomicIntegerArray.length());
}
}
}
}
}
输出结果：
//10个线程，每个线程自增1000次
[10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000, 10000]
字段更新器
AtomicLongFieldUpdater，AtomicIntegerFieldUpdater，AtomicReferenceFieldUpdater基于反射的实用工具，可以对指定类的指定 volatile 字段进行原子更新。API非常简单，但是也是有一些约束：
（1）字段必须是volatile类型的
（2）字段的描述类型（修饰符public/protected/default/private）是与调用者与操作对象字段的关系一致。也就是说 调用者能够直接操作对象字段，那么就可以反射进行原子操作。但是对于父类的字段，子类是不能直接操作的，尽管子类可以访问父类的字段。
（3）只能是实例变量，不能是类变量，也就是说不能加static关键字。
（4）只能是可修改变量，不能使final变量，因为final的语义就是不可修改。实际上final的语义和volatile是有冲突的，这两个关键字不能同时存在。
（5）对于AtomicIntegerFieldUpdater 和AtomicLongFieldUpdater 只能修改int/long类型的字段，不能修改其包装类型（Integer/Long）。如果要修改包装类型就需要使用AtomicReferenceFieldUpdater 。
netty5.0中类ChannelOutboundBuffer统计发送的字节总数，由于使用volatile变量已经不能满足，所以使用AtomicIntegerFieldUpdater 来实现的
示例：
//定义一个User实体类
public class User {
int id;
volatile int age;
public User(int id, int age) {
this.id = id;
this.age = age;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", age=" + age +
'}';
}
}
//定义一个线程类，实现字段自增
public class AtomicUpdater extends Thread{
private User user;
private AtomicIntegerFieldUpdater<User> updater = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
public AtomicUpdater(User user) {
this.user = user;
}
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(updater.getAndIncrement(user));
}
}
}
//测试类
public class Test {
public static void main(String[] args) {
//初始化User对象
User user = new User(1, 10);
//开启10个线程
for (int i = 0; i < 10; i++) {
new AtomicUpdater(user).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(user);
}
}
输出结果：
//一个线程自增10次，10个线程自增100次
User{id=1, age=110}
引用型
原子更新基本类型的AtomicInteger，只能更新一个变量，如果要原子更新多个变量，就需要使用这个原子更新引用类型提供的类。Atomic包提供了以下3个类
AtomicReference
import java.util.concurrent.atomic.AtomicReference;
public class AtomicReferenceTest {
static AtomicReference<String> atomicReference=new AtomicReference<>("abc");
public static void main(String[] args) {
//创建十个线程修改字符串
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
if (atomicReference.compareAndSet("abc","def")){
System.out.println(Thread.currentThread().getName()+"把字符串修改为了def");
}
}
}).start();
}
//再创建100个线程
for (int i = 0; i < 100; i++) {
new Thread(new Runnable() {
@Override
public void run() {
if (atomicReference.compareAndSet("def","abc")){
System.out.println(Thread.currentThread().getName()+"把字符串还原为了abc");
}
}
}).start();
}
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(atomicReference.get());
}
}
AtomicStampedReference
由于atomicReference是采用了CAS，所以可能会产生ABA问题。利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在ABA问题了。这就是AtomicStampedReference的解决方案。
public class AtomicStampReferenceTest {
//定义AtomicStampedReference引用操作"abc"字符串，指定初始版本号为0
private static AtomicStampedReference<String> stampedReference=new AtomicStampedReference<>("abc",0);
public static void main(String[] args) {
Thread t1=new Thread(new Runnable() {
@Override
public void run() {
stampedReference.compareAndSet("abc","def",
stampedReference.getStamp(),
stampedReference.getStamp()+1);
System.out.println(Thread.currentThread().getName()+"----"+stampedReference.getReference());
stampedReference.compareAndSet("def","abc",
stampedReference.getStamp(),
stampedReference.getStamp()+1);
}
});
Thread t2=new Thread(new Runnable() {
//如果在此处获取stamp，则可能无法获取当前的版本号，在线程睡眠的那一秒中，版本号可能发生了改变
//int stamp=stampedReference.getStamp();//获取版本号
@Override
public void run() {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
int stamp=stampedReference.getStamp();//获取版本号
System.out.println(stampedReference.compareAndSet("abc","ggg",stamp,stamp+1));
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(stampedReference.getReference());
}
}
AtomicMarkableReference
原子更新带有标记位的引用类型。可以原子更新一个布尔类型的标记位和引用类型。构造方法是AtomicMarkableReference（V initialRef，booleaninitialMark）
