原子操作类

原子操作类

AtomicInteger 源码解析

java.util.concurrent.atomic下的所有原子操作类都实现了 CAS。

AtomicInteger 内部维护一个变量 Unsafe：

private static final Unsafe unsafe = Unsafe.getUnsafe(); 

Unsafe 类中可以执行以下几种操作：

• 分配内存，释放内存。allocateMemory，reallocateMemory，freeMemory
• 挂起和唤醒线程。被封装在 LockSupport 类中供使用
• CAS 操作

J.U.C 包里面的整数原子类 AtomicInteger 的方法调用了 Unsafe 类的 CAS 操作。

以下代码使用了 AtomicInteger 执行了自增的操作。

private AtomicInteger cnt = new AtomicInteger();

public void add() {
    cnt.incrementAndGet();
}

以下代码是 incrementAndGet() 的源码，它调用了 Unsafe 的 getAndAddInt() 。

public final int incrementAndGet() {
    return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
}

以下代码是 getAndAddInt() 源码，var1 指示对象内存地址，var2 指示该字段相对对象内存地址的偏移，var4 指示操作需要加的数值，这里为 1。通过 getIntVolatile(var1, var2) 得到旧的预期值，通过调用 compareAndSwapInt() 来进行 CAS 比较，如果该字段内存地址中的值等于 var5，那么就更新内存地址为 var1+var2 的变量为 var5+var4。

可以看到 getAndAddInt() 在一个循环中进行，发生冲突的做法是不断的进行重试。

public final int getAndAddInt(Object var1, long var2, int var4) {
    int var5;
    do {
        var5 = this.getIntVolatile(var1, var2);
    } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));

    return var5;
}

除了 CAS 操作外，AtomicInteger 还使用 volatile 和 native 方法来保证原子操作，从而避免 synchronized 的高开销，执行效率大为提升。

private static final Unsafe unsafe = Unsafe.getUnsafe();
private static final long valueOffset;

static {
    try {
        valueOffset = unsafe.objectFieldOffset
            (AtomicInteger.class.getDeclaredField("value"));
    } catch (Exception ex) { throw new Error(ex); }
}

private volatile int value;

UnSafe 类的 objectFieldOffset() 方法是一个 native 方法，这个方法是用来拿到 “原来的值” 的内存地址，返回值是 valueOffset。

另外 value 是一个volatile变量，在内存中可见，因此 JVM 可以保证任何时刻任何线程总能拿到该变量的最新值。

原子更新基本类

atomic 包提高原子更新基本类的工具类，如下：

• AtomicBoolean
• AtomicInteger
• AtomicLong

以 AtomicInteger 为例总结常用的方法:

addAndGet(int delta) //以原子方式将输入的数值与实例中原本的值相加，并返回最后的结果

incrementAndGet() //以原子的方式将实例中的原值进行加1操作，并返回最终相加后的结果

getAndSet(int newValue) //将实例中的值更新为新值，并返回旧值

getAndIncrement() //以原子的方式将实例中的原值加1，返回的是自增前的旧值

AtomicInteger 的 getAndIncrement() 方法源码如下：

public final int getAndIncrement() {
    return unsafe.getAndAddInt(this, valueOffset, 1);
}

测试用例：

public class AtomicIntegerDemo {
    // 请求总数
    public static int clientTotal = 5000;

    // 同时并发执行的线程数
    public static int threadTotal = 200;

    //java.util.concurrent.atomic.AtomicInteger;
    public static AtomicInteger count = new AtomicInteger(0);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executorService = Executors.newCachedThreadPool();
        //Semaphore和CountDownLatch模拟并发
        //Semaphore 控制并发的数量
        //CountDownLatch 用于控制一个线程等待多个线程
        final Semaphore semaphore = new Semaphore(threadTotal);
        final CountDownLatch countDownLatch = new CountDownLatch(clientTotal);
        for (int i = 0; i < clientTotal ; i++) {
            executorService.execute(() -> {
                try {
                    semaphore.acquire();
                    add();
                    semaphore.release();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        countDownLatch.await();
        executorService.shutdown();
        System.out.println("count:{"+count.get()+"}");
    }

    public static void add() {
        count.incrementAndGet();
    }
}

输出结果：

count:{5000}

AtomicLong 的实现原理和 AtomicInteger 一致，只不过针对的是 long 变量。 boolean 变量的更新类 AtomicBoolean 类核心方法是 compareAndSet() 方法，其源码如下：

public final boolean compareAndSet(boolean expect, boolean update) {
    int e = expect ? 1 : 0;
    int u = update ? 1 : 0;
    return unsafe.compareAndSwapInt(this, valueOffset, e, u);
}

可以看出，compareAndSet 方法的实际上也是先转换成 0,1 的整型变量，然后是通过针对 int 型变量的原子更新方法 compareAndSwapInt 来实现的。

原子更新数组

atomic 包下提供能原子更新数组中元素的类有：

• AtomicIntegerArray
• AtomicLongArray
• AtomicReferenceArray

这几个类的用法一致，就以AtomicIntegerArray来总结下常用的方法：

getAndAdd(int i, int delta) //以原子更新的方式将数组中索引为i的元素与输入值相加

getAndIncrement(int i) //以原子更新的方式将数组中索引为i的元素自增加1

compareAndSet(int i, int expect, int update) //将数组中索引为i的位置的元素进行更新

可以看出，AtomicIntegerArray 与AtomicInteger 的方法基本一致，只不过在 AtomicIntegerArray 的方法中会多一个指定数组索引位 i。

public class AtomicIntegerArrayDemo {
    private static int[] value = new int[]{1, 2, 3};
    private static AtomicIntegerArray integerArray = new AtomicIntegerArray(value);

    public static void main(String[] args) {
        //对数组中索引为1的位置的元素加5
        int result = integerArray.getAndAdd(1, 5);
        System.out.println(integerArray.get(1));
        System.out.println(result);
    }
}

输出结果：

7
2  //注意仍然返回原来的旧值

原子更新引用类型

如果需要原子更新引用类型变量的话，为了保证线程安全，atomic 也提供了相关的类：

• AtomicReference
• AtomicReferenceFieldUpdater。原子更新引用类型里的字段。
• AtomicMarkableReference。原子更新带有标记位的引用类型。

这几个类的使用方法也是基本一样的，以AtomicReference为例。

public class AtomicReferenceDemo {

    private static AtomicReference<User> reference = new AtomicReference<>();

    public static void main(String[] args) {
        User user1 = new User("a", 1);
        reference.set(user1);
        User user2 = new User("b",2);
        User user = reference.getAndSet(user2);
        System.out.println(user);
        System.out.println(reference.get());
    }

    static class User {
        private String userName;
        private int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出结果：

User{userName='a', age=1}
User{userName='b', age=2}

首先将对象 user1 用 AtomicReference 进行封装，然后调用 getAndSet 方法，从结果可以看出，该方法会原子更新引用的 User 对象，变为User{userName='b', age=2}，返回的是原来的User 对象User{userName='a', age=1}。

原子更新字段类型

如果需要更新对象的某个字段，并在多线程的情况下，能够保证线程安全，atomic同样也提供了相应的原子操作类：

• AtomicIntegeFieldUpdater
• AtomicLongFieldUpdater
• AtomicStampedReference。原子更新引用类型，这种更新方式会带有版本号，为了解决 CAS 的 ABA 问题。

要想使用原子更新字段需要两步操作：

• 原子更新字段类都是抽象类，只能通过静态方法 newUpdater 来创建一个更新器，并且需要设置想要更新的类和属性

• 更新类的属性必须使用 public volatile 进行修饰

这几个类提供的方法基本一致，以 AtomicIntegerFieldUpdater 为例。

public class AtomicIntegerFieldUpdaterDemo {
    private static AtomicIntegerFieldUpdater updater =
        AtomicIntegerFieldUpdater.newUpdater(User.class,"age");

    public static void main(String[] args) {
        User user = new User("a", 1);
        int oldValue = updater.getAndAdd(user, 5);
        System.out.println(oldValue);
        System.out.println(updater.get(user));
    }

    static class User {
        private String userName;
        public volatile int age;

        public User(String userName, int age) {
            this.userName = userName;
            this.age = age;
        }

        @Override
        public String toString() {
            return "User{" +
                    "userName='" + userName + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出结果：

1
6

创建 AtomicIntegerFieldUpdater 是通过它提供的静态方法进行创建，getAndAdd 方法会将指定的字段加上输入的值，并且返回相加之前的值。 User对象中 age 字段原值为 1，加 5 之后，可以看出 user 对象中的 age 字段的值已经变成了 6。

https://www.mianshi.online，https://www.i9code.cn

本文由博客一文多发平台 OpenWrite 发布！