1、What and Why
原子的本意是不能被分割的粒子，而对于一个操作来说，如果它是不可被中断的一个或者一组操作，那么他就是原子操作。显然，原子操作是安全的，因为它不会被打断。
平时我们见到的很多操作看起来是原子操作，但其实是非原子操作，例如很常见的i++操作，它背后有取值、加一、写回等操作，如果有两个线程都要对 i 进行加一操作，就有可能结果把i只变成了2，这就是线程不安全的更新操作，当然我们可以使用synchronized解决，但是JUC提供了java.util.concurrent.atomic包，这个包的原子操作类提供了一种简单高效、线程安全地更新一个变量的方式。
2、原子更新基本类型类
使用原子的方式更新基本类型，Atomic包提供了以下3个类：
-
AtomicBoolean：原子更新布尔类型
-
AtomicInteger：原子更新整型
-
AtomicLong：原子更新长整型
上面三个类型的方法几乎一模一样，下面以AtomicInteger为例介绍以下他们的方法
-
int addAndGet(int data)：以原子操作的方式将输入data与AtomicInteger原有的值相加，并返回结果。
-
boolean compareAndSet(int expect, int update)：如果输入的数值等于预期值expect，则以原子操作的方式将update赋给AtomicInteger原有的值。
-
getAndIncrement()：以原子操作的方式给AtomicInteger原有的值加一，但是注意这个方法返回的值是自增前的值。
-
int getAndSet(int newValue)：以原子操作的方式给AtomicInteger原有的值设置成newValue的值
-
void lazySet(int newValue)：最终会设置成newValue，但是使用lazyset设置之后，可能会导致其他线程在之后的一小段时间内还可以读到旧值。
class AtomicIntegerDemo{
static AtomicInteger atomicInteger = new AtomicInteger(0);
public static void main(String[] args) {
//新建一个线程池
ExecutorService threadPoolExecutor = new ThreadPoolExecutor(2,
4,
100,
TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<Runnable>(10),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
// 新建一个线程
threadPoolExecutor.execute(
() -> {
for (int i = 0; i < 10; i++) {
atomicInteger.incrementAndGet();
}
});
//新建一个线程
threadPoolExecutor.execute(()->{
for (int i = 0; i < 10; i++) {
atomicInteger.incrementAndGet();
}
});
System.out.println(atomicInteger.get());
threadPoolExecutor.shutdown();
}
}
|
3、实现原理
public final int incrementAndGet() {
return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}
|
其中，unsafe类是Java用来处理一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，它使得Java拥有了类似C语言一样操作内存空间的能力。
valueOffset是字段value的内存偏移地址，valueOffset的值在AtomicInteger初始化时，在静态代码块中通过Unsafe的objectFieldOffset方法获取。在AtomicInteger中提供的线程安全方法中，通过字段valueOffset的值可以定位到AtomicInteger对象中value的内存地址，从而可以根据CAS实现对value字段的原子操作。
public final int getAndAddInt(Object o, long offset, int delta) {
int v;
do {
v = getIntVolatile(o, offset);
} while (!compareAndSwapInt(o, offset, v, v + delta));
return v;
}
|
打开getAndAddInt()函数，可以看到这里使用了一个CAS机制的自旋锁来对v值进行赋值,关于CAS机制可以查看文章Java多线程 乐观锁和CAS机制
，getIntVolatile方法用于获取对象o指定偏移量的int值，此操作具有volatile内存语义，也就是说，即使对象o指定offset的变量不是volatile的，次操作也会使用volatile语义，会强制从主存获取值，然后通过compareAndSwapInt来替换值，直到替换成功后，退出循环。
4、原子更新数组
使用原子的方式更新数组中的某个元素，Atomic包提供了以下3个类：
-
AtomicReferenceArray：原子更新引用类型数组中的元素
-
AtomicIntegerArray：原子更新整型数组中的元素
-
AtomicLongArray：原子更新长整型数组中的元素
下面以AtomicIntegerArray为例介绍以下他们的方法：
1.int addAndGet(int i, int delta)：以原子的方式将输入值与数组中索引i的元素相加。
2.boolean compareAndSet(int i, int expect, int update)：如果当前值等于预期值，则以原子方式将数组位置i的元素设置成update值
5、原子更新引用类型
刚刚提到的只能一次更新一个变量，如果要更新多个变量就需要使用原子更新引用类型提供的类了：
-
AtomicReference：原子更新引用类型
-
AtomicReferenceFieldUpdater：原子更新引用类型里的字段
-
AtomicMarkableReference：原子更新带有标记位的引用类型。可以原子地更新一个布尔类型地标记位和引用类型。
AtomicReference 示例
class User{
private String name;
public volatile int age;
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public User(String name, int age) {
this.name = name;
this.age = age;
}
}
class Reference
{
static AtomicReference<User> atomicUser = new AtomicReference<>();
public static void main(String[] args) {
User u = new User("1",10);
atomicUser.set(u);
System.out.println(atomicUser.get());
atomicUser.compareAndSet(u,new User("2",15));
System.out.println(atomicUser.get());
System.out.println(atomicUser.compareAndSet(u, new User("3", 123)));
System.out.println(atomicUser.compareAndSet(new User("2", 15), u));
}
}
|
AtomicReferenceFieldUpdate
class AtomicFiled
{
static AtomicReferenceFieldUpdater<User,String> nameField = AtomicReferenceFieldUpdater.newUpdater(User.class,String.class,"name");
public static void main(String[] args) {
//
User u = new User("123",10);
System.out.println(u);
System.out.println(nameField.compareAndSet(u, "123", "xiaohua"));
System.out.println(u);
System.out.println(nameField.compareAndSet(u,"123","xiaoli"));
}
}
|
AtomicMarkableReference 示例
前面介绍的都是在原子操作下对一个数据进行修改，AtomicMarkableReference 不同的是，它不仅可以修改，还定义了一个变量去判断是他之前是否已经被修改过了，这里就不得不提到ABA问题了：
ABA问题就是如果一个线程把变量a的值由1变成2，另一个线程又把变量a的值由2变回了1，这个时候变量a的值相当于没有变过，但实际上其实已经被更改了，这就是ABA问题。可以举一个更形象的例子，杯子里有一杯水，小明把它喝完了，之后又接满水放回原处，这时小华来了如果知道了杯子被人用过那肯定不会再喝了，如果小明喝完之后那张纸记录下已经用过，那么小华来了就知道了。AtomicMarkableReference就提供了这样一个布尔变量记录值是否被修改过。
AtomicMarkableReference初始化时需要传入一个引用值（类型就是前面填的泛型），此外还需要传入一个布尔值用作判断是否修改。AtomicMarkableReference的compareAndSet要传入两组参数：旧的引用值和新的引用值；旧的布尔值和新的布尔值，只有传入的旧引用值和旧布尔值与对象中的值相同，才会修改引用值和布尔值。
class AtomicFiled
{
static AtomicMarkableReference<Integer> intMarkable = new AtomicMarkableReference<>(123,false);
public static void main(String[] args) {
System.out.println(intMarkable.getReference());
System.out.println(intMarkable.isMarked());
System.out.println(intMarkable.compareAndSet(123,100,false,true));
System.out.println(intMarkable.getReference());
System.out.println(intMarkable.isMarked());
System.out.println(intMarkable.compareAndSet(100,123,false,true));
}
}
|
6、原子更新字段类
如果需要原子地更新某个类中的字段时，就需要使用原子更新字段类，Atomic包提供了下面3个类：
-
AtomicIntegerFieldUpdater：原子更新整型的字段的更新器
-
AtomicLongFieldUpdater：原子更新长整型的字段的更新器
-
AtomicStampedReference：原子更新带版本号的引用类型。使用版本号解决ABA问题
需要注意的是，原子地更新字段类需要两步：第一步需要用静态方法newUpdate()创建一个更新器，并且设置想要更新的类和属性。第二步，更新类的字段（属性）必须使用public volatile修饰符。
public class AtomicDemo {
static AtomicReference<User> atomicUsers = new AtomicReference<>();
static AtomicIntegerFieldUpdater<User> userAge = AtomicIntegerFieldUpdater.newUpdater(User.class,"age");
static CountDownLatch countDownLatch = new CountDownLatch(2);
public static void main(String[] args) throws InterruptedException {
User u = new User("123",0);
atomicUsers.set(u);
ExecutorService threadPoolExecutor = new ThreadPoolExecutor(3,
6,
100,
TimeUnit.MILLISECONDS,
new ArrayBlockingQueue<Runnable>(10),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
threadPoolExecutor.execute(()->
{
try {
TimeUnit.MILLISECONDS.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+" "+atomicUsers.get().getAge());
userAge.incrementAndGet(u);
countDownLatch.countDown();
});
threadPoolExecutor.shutdown();
countDownLatch.await();
System.out.println(atomicUsers.get().getAge());
}
}
|
