atomicinteger java8_AtomicInteger源码解析-Java8

前言

最近在看JDK源码，发现好多地方都用到了AtomicInteger原子类，所以打算将AtmoicInteger的源码过一遍。

本文将分为两部分，一部分是简单介绍AtmoicInteger的用法，第二部分是AtomicInteger的源码，我在源码中做了比较详细的注释。

简单使用AtomicInteger

下面介绍AtomicInteger的一部分API的使用示例，未列出的api可以在后面的源码中看到用法

package cn.ganlixin;

import org.junit.Test;

import java.util.concurrent.atomic.AtomicInteger;

/**

* 描述:

* 测试使用AtomicInteger

*

* @author ganlixin

* @create 2020-06-11

*/

public class TestAtomicInteger {

@Test

public void test() {

AtomicInteger atomicInteger = new AtomicInteger();

// AtomicInteger ai = new AtomicInteger(10); 赋初始值为10

System.out.println(atomicInteger.get()); // 0

// 修改值

atomicInteger.set(100);

// 获取当前值，然后设置新值

System.out.println(atomicInteger.getAndSet(99));// 100

System.out.println(atomicInteger.get()); // 99

// 获取当前值，然后对其进行加20

System.out.println(atomicInteger.getAndAdd(20)); // 99

System.out.println(atomicInteger.get()); // 119

// lazySet和set功能一样，但是不能保证立即修改值(最终会修改)

atomicInteger.lazySet(100);

System.out.println(atomicInteger.get()); // 100

// 新增1并返回新值，原子操作

System.out.println(atomicInteger.incrementAndGet()); // 101

// CAS原子操作更改value

System.out.println(atomicInteger.compareAndSet(102, 1000)); // false

System.out.println(atomicInteger.compareAndSet(101, 1000)); // true

}

}

AtomicInteger源码

源码如下，AtomicInteger的源码还是比较好理解的，基本没有难点，其中涉及到Unsafe类的使用，可以美团技术博客(Java魔法类-Unsafe应用解析)。

package java.util.concurrent.atomic;

import sun.misc.Unsafe;

import java.util.function.IntBinaryOperator;

import java.util.function.IntUnaryOperator;

/**

* 原子类

*/

public class AtomicInteger extends Number implements java.io.Serializable {

private static final long serialVersionUID = 6214790243416807050L;

// Unsafe可以执行低级别、不安全操作的方法，比如直接访问系统内存资源、自主管理内存资源等

// 使用Unsafe，可以实现内存操作、CAS、内存屏障...在AtomicInteger中，主要用来进行CAS操作

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

// value就是AtomicInteger保存的值，因为加了volatile关键字，所以在并发操作时，多线程能感知数据发生变化

private volatile int value;

// 该字段用来保存内存偏移地址，会在下面的静态代码块初始化

private static final long valueOffset;

static {

try {

// valueOffset为字段value的内存偏移地址(相对于atomicInteger对象基地址的偏移)

valueOffset = unsafe.objectFieldOffset(AtomicInteger.class.getDeclaredField("value"));

} catch (Exception ex) {

throw new Error(ex);

}

}

/**

* 创建AtomicInteger对象，并设置初始值

*

* @param initialValue 初始值

*/

public AtomicInteger(int initialValue) {

value = initialValue;

}

/**

* 创建AtomicInteger对象，初始值为0

*/

public AtomicInteger() {

}

/**

* 获取value.

*

* @return 当前的value

*/

public final int get() {

return value;

}

/**

* 立即修改或者设置value

* set操作能够保证可见性，避免指令重排

*

* @param newValue 设置的新值

*/

public final void set(int newValue) {

value = newValue;

}

/**

* 不会立即修改或者设置值(但是最终会)

* lazySet不能保证可见性，可能会发生指令重排，但是性能比set高

*

* @param newValue 要设置的值

* @since 1.6

*/

public final void lazySet(int newValue) {

unsafe.putOrderedInt(this, valueOffset, newValue);

}

/**

* 设置新值，并且返回旧值(原子操作)

*

* @param newValue 新值

* @return 旧值

*/

public final int getAndSet(int newValue) {

return unsafe.getAndSetInt(this, valueOffset, newValue);

}

/**

* 原子操作，CAS，当value和expect相等时，才将value修改为update

*

* @param expect 期望value的值

* @param update 要修改的值

* @return true:value和expect相等，且完成修改；false:value和expect不相等

*/

public final boolean compareAndSet(int expect, int update) {

return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

}

/**

* 和compareAndSet相同功能，都是使用CAS原子操作，但是无法保证多个线程CAS的有序性

*

* @param expect 期望的value值

* @param update 更改后的值

* @return 操作是否成功

*/

public final boolean weakCompareAndSet(int expect, int update) {

return unsafe.compareAndSwapInt(this, valueOffset, expect, update);

}

/**

* 将value加1，然后返回旧值，原子操作

*

* @return 旧值

*/

public final int getAndIncrement() {

return unsafe.getAndAddInt(this, valueOffset, 1);

}

/**

* 将value减1，然后返回旧值，原子操作

*

* @return 旧值

*/

public final int getAndDecrement() {

return unsafe.getAndAddInt(this, valueOffset, -1);

}

/**

* 对value增加指定值，然后返回旧值，原子操作

*

* @param delta 要加的值

* @return 旧值

*/

public final int getAndAdd(int delta) {

return unsafe.getAndAddInt(this, valueOffset, delta);

}

/**

* 将value加1，并返回新值，原子操作

*

* @return value加1后的值

*/

public final int incrementAndGet() {

return unsafe.getAndAddInt(this, valueOffset, 1) + 1;

}

/**

* 将value减1，并返回新值，原子操作

*

* @return value减1后的新值

*/

public final int decrementAndGet() {

return unsafe.getAndAddInt(this, valueOffset, -1) - 1;

}

/**

* 对value增加值，然后返回新值，原子操作

*

* @param delta 新增的值

* @return value新增后的值

*/

public final int addAndGet(int delta) {

return unsafe.getAndAddInt(this, valueOffset, delta) + delta;

}

/**

* 传入Function，对value进行操作(同样使用CAS保证原子性)，会一直重试直到成功才中断，然后返回旧值

*

* @param updateFunction a side-effect-free function

* @return 旧值

* @since 1.8

*/

public final int getAndUpdate(IntUnaryOperator updateFunction) {

int prev, next;

do {

prev = get();

next = updateFunction.applyAsInt(prev);

} while (!compareAndSet(prev, next));

return prev;

}

/**

* 传入Function，对value进行操作(同样使用CAS保证原子性)，会一直重试直到成功才中断，然后返回新值

*

* @param updateFunction a side-effect-free function

* @return the updated value

* @since 1.8

*/

public final int updateAndGet(IntUnaryOperator updateFunction) {

int prev, next;

do {

prev = get();

next = updateFunction.applyAsInt(prev);

// 一直重试，直到CAS操作成功

} while (!compareAndSet(prev, next));

return next;

}

/**

* Atomically updates the current value with the results of

* applying the given function to the current and given values,

* returning the previous value. The function should be

* side-effect-free, since it may be re-applied when attempted

* updates fail due to contention among threads. The function

* is applied with the current value as its first argument,

* and the given update as the second argument.

*

* @param x the update value

* @param accumulatorFunction a side-effect-free function of two arguments

* @return the previous value

* @since 1.8

*/

public final int getAndAccumulate(int x, IntBinaryOperator accumulatorFunction) {

int prev, next;

do {

prev = get();

next = accumulatorFunction.applyAsInt(prev, x);

} while (!compareAndSet(prev, next));

return prev;

}

/**

* Atomically updates the current value with the results of

* applying the given function to the current and given values,

* returning the updated value. The function should be

* side-effect-free, since it may be re-applied when attempted

* updates fail due to contention among threads. The function

* is applied with the current value as its first argument,

* and the given update as the second argument.

*

* @param x the update value

* @param accumulatorFunction a side-effect-free function of two arguments

* @return the updated value

* @since 1.8

*/

public final int accumulateAndGet(int x, IntBinaryOperator accumulatorFunction) {

int prev, next;

do {

prev = get();

next = accumulatorFunction.applyAsInt(prev, x);

} while (!compareAndSet(prev, next));

return next;

}

public String toString() {

return Integer.toString(get());

}

public int intValue() {

return get();

}

public long longValue() {

return (long) get();

}

public float floatValue() {

return (float) get();

}

public double doubleValue() {

return (double) get();

}

}