java并发之 Atomic_综合

基本原子类 AtomicInteger

在其字段里，这两个字段最为重要

	private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();private volatile int value;//value

这里的value需要注意是volatile的，它保证了该变量在并发过程中的可见性、有序性。但不保证原子性（复合操作，单独的读写操作还是满足原子性的，于是原子类实现了原子性）

常用方法以及实现

	public final int get() {
    return value;}

	public final void set(int newValue) {
    value = newValue;}

//获取当前值，并设置新的值public final int getAndSet(int newValue) {
    return U.getAndSetInt(this, VALUE, newValue);}

//cas，没什么好说的，直接调用的Unsafe类的cas方法public final boolean compareAndSet(int expectedValue, int newValue) {
    return U.compareAndSetInt(this, VALUE, expectedValue, newValue);}

//获取当前值，并自增
//该方法我们重点看一下，因为对于一个volatile变量来说++是非原子性的
//而这里保证了原子性public final int getAndIncrement() {
    return U.getAndAddInt(this, VALUE, 1);}@HotSpotIntrinsicCandidatepublic final int getAndAddInt(Object o, long offset, int delta) {
    int v;do {
    v = getIntVolatile(o, offset);} while (!weakCompareAndSetInt(o, offset, v, v + delta));return v;}

可以看到，这里进行自增的逻辑，就是一个写操作，先获取原值v，然后写入v+1，和对于volatile的value++实际逻辑是一样，不同点在于，这里用了CAS，来确保原子性。

//如果输入的数值等于预期值，则以原子方式将该值设置为输入值（update）public final boolean compareAndSet(int expectedValue, int newValue) {
    return U.compareAndSetInt(this, VALUE, expectedValue, newValue);}

//最终设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。public final void lazySet(int newValue) {
    U.putIntRelease(this, VALUE, newValue);}

总结一下，就是 volatile + cas，于是便在volatile的基础上实现了原子性

除了AtomicInteger，还有两个原子基本类，本质上差不多，就不赘述了

AtomicInteger：整型原子类
AtomicLong：长整型原子类
AtomicBoolean ：布尔型原子类

数组类型原子类AtomicIntegerArray

数组类型的原子类
~~这里的实现目前还没有看懂，后面有机会有需要的话补上好了~~

public final int get(int i) //获取 index=i 位置元素的值
public final int getAndSet(int i, int newValue)//返回 index=i 位置的当前的值，并将其设置为新值：newValue
public final int getAndIncrement(int i)//获取 index=i 位置元素的值，并让该位置的元素自增
public final int getAndDecrement(int i) //获取 index=i 位置元素的值，并让该位置的元素自减
public final int getAndAdd(int i, int delta) //获取 index=i 位置元素的值，并加上预期的值
boolean compareAndSet(int i, int expect, int update) //如果输入的数值等于预期值，则以原子方式将 index=i 位置的元素值设置为输入值（update）
public final void lazySet(int i, int newValue)//最终 将index=i 位置的元素设置为newValue,使用 lazySet 设置之后可能导致其他线程在之后的一小段时间内还是可以读到旧的值。

数组类型的原子类共有这些：

AtomicIntegerArray：整型数组原子类
AtomicLongArray：长整型数组原子类
AtomicReferenceArray ：引用类型数组原子类

引用原子类

主要有：

AtomicReference：引用类型原子类，其cas的话，主要是对比之前指向的对象，但会遇到ABA问题，就是一开始获取了对象为A，另一个线程将其修改为B，然后又修改成A，之后对于原线程来说，意味该原子引用类没有变化过，其实已经变过了。应用场景：多个线程给账户低于20的打钱（只打一次），该账户在收到钱的同时，把钱花了，又低于20，此时有可能另外的线程又给该账户打了一次钱，从而超过了两次，于是出了问题
AtomicStampedReference：为了解决ABA问题，该引用类型产生，伴随着引用对象，它还有个时间戳，在内部是Pair类的reference字段和stamp字段。每次修改引用就得同时修改时间戳，那么在进行cas的时候，不仅判断引用是不是原来那个，还要判断时间戳是不是原来那个
AtomicMarkableReference ：stamp的简化版，stamp如果是++的方式修改的话，那么很容易就知道在某某过程中，该引用被修改了多少次。本引用类不关心修改了多少次，只关心有没有被修改，用一个布尔类型来标记是否修改过

这里的应用场景可以参考https://my.oschina.net/u/1262062/blog/886151

对象属性修改原子类

如果需要原子更新某个类里的某个字段时，需要用到对象的属性修改类型原子类。

AtomicIntegerFieldUpdater:原子更新整形字段的更新器
AtomicLongFieldUpdater：原子更新长整形字段的更新器
AtomicReferenceFieldUpdater ：原子更新引用类型里的字段的更新器

要想原子地更新对象的属性需要两步。第一步，因为对象的属性修改类型原子类都是抽象类，所以每次使用都必须使用静态方法 **newUpdater()**创建一个更新器（进行包装），并且需要设置想要更新的类和属性。第二步，更新的对象属性必须使用 public volatile 修饰符。

import java.util.concurrent.atomic.AtomicIntegerFieldUpdater;public class AtomicIntegerFieldUpdaterTest {
    public static void main(String[] args) {
    AtomicIntegerFieldUpdater<User> a = AtomicIntegerFieldUpdater.newUpdater(User.class, "age");User user = new User("Java", 22);System.out.println(a.getAndIncrement(user));// 22System.out.println(a.get(user));// 23}
}class User {
    private String name;public volatile int age;public User(String name, int age) {
    super();this.name = name;this.age = age;}public String getName() {
    return name;}public void setName(String name) {
    this.name = name;}public int getAge() {
    return age;}public void setAge(int age) {
    this.age = age;}}

参考

JUC 中的 Atomic 原子类总结