JUC原子类

最新推荐文章于 2023-10-04 09:43:20 发布

会走的桃子

最新推荐文章于 2023-10-04 09:43:20 发布

阅读量684

点赞数

分类专栏： java 文章标签：多线程 JAVA

java 专栏收录该内容

12 篇文章 1 订阅

订阅专栏

文章目录

数据类型
AtomicInteger, AtomicLong, AtomicBoolean
AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray
AtomicReference
AtomicIntegerFieldUpdater, AtomicLongFieldUpdater,AtomicReferenceFieldUpdater

数据类型

根据修改的数据类型，可以将JUC包中的原子操作类可以分为4类。

基本类型: AtomicInteger, AtomicLong, AtomicBoolean ;
数组类型: AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray ;
引用类型: AtomicReference, AtomicStampedRerence, AtomicMarkableReference ;
对象的属性修改类型: AtomicIntegerFieldUpdater, AtomicLongFieldUpdater, AtomicReferenceFieldUpdater 。

这些类存在的目的是对相应的数据进行原子操作。所谓原子操作，是指操作过程不会被中断，保证数据操作是以原子方式进行的。

AtomicInteger, AtomicLong, AtomicBoolean

AtomicInteger, AtomicLong和AtomicBoolean这3个基本类型的原子类的原理和用法相似。本章以AtomicLong对基本类型的原子类进行介绍。

AtomicLong是作用是对长整形进行原子操作。
在32位操作系统中，64位的long 和 double 变量由于会被JVM当作两个分离的32位来进行操作，所以不具有原子性。而使用AtomicLong能让long的操作保持原子型。

public class AtomicLong extends Number implements java.io.Serializable {
	// 构造函数
	AtomicLong()
	// 创建值为initialValue的AtomicLong对象
	AtomicLong(long initialValue)
	// 以原子方式设置当前值为newValue。
	final void set(long newValue) 
	// 获取当前值
	final long get() 
	// 以原子方式将当前值减 1，并返回减1后的值。等价于“--num”
	final long decrementAndGet() 
	// 以原子方式将当前值减 1，并返回减1前的值。等价于“num--”
	final long getAndDecrement() 
	// 以原子方式将当前值加 1，并返回加1后的值。等价于“++num”
	final long incrementAndGet() 
	// 以原子方式将当前值加 1，并返回加1前的值。等价于“num++”
	final long getAndIncrement()    
	// 以原子方式将delta与当前值相加，并返回相加后的值。
	final long addAndGet(long delta) 
	// 以原子方式将delta添加到当前值，并返回相加前的值。
	final long getAndAdd(long delta) 
	// 如果当前值 == expect，则以原子方式将该值设置为update。成功返回true，否则返回false，并且不修改原值。
	final boolean compareAndSet(long expect, long update)
	// 以原子方式设置当前值为newValue，并返回旧值。
	final long getAndSet(long newValue)
	// 返回当前值对应的int值
	int intValue() 
	// 获取当前值对应的long值
	long longValue()    
	// 以 float 形式返回当前值
	float floatValue()    
	// 以 double 形式返回当前值
	double doubleValue()    
	// 最后设置为给定值。延时设置变量值，这个等价于set()方法，但是由于字段是volatile类型的，因此次字段的修改会比普通字段（非volatile字段）有稍微的性能延时（尽管可以忽略），所以如果不是想立即读取设置的新值，允许在“后台”修改值，那么此方法就很有用。如果还是难以理解，这里就类似于启动一个后台线程如执行修改新值的任务，原线程就不等待修改结果立即返回（这种解释其实是不正确的，但是可以这么理解）。
	final void lazySet(long newValue)
	// 如果当前值 == 预期值，则以原子方式将该设置为给定的更新值。JSR规范中说：以原子方式读取和有条件地写入变量但不 创建任何 happen-before 排序，因此不提供与除 weakCompareAndSet 目标外任何变量以前或后续读取或写入操作有关的任何保证。大意就是说调用weakCompareAndSet时并不能保证不存在happen-before的发生（也就是可能存在指令重排序导致此操作失败）。但是从Java源码来看，其实此方法并没有实现JSR规范的要求，最后效果和compareAndSet是等效的，都调用了unsafe.compareAndSwapInt()完成操作。
	final boolean weakCompareAndSet(long expect, long update)

}

AtomicLong的代码很简单，下面仅以incrementAndGet()为例，对AtomicLong的原理进行说明。
incrementAndGet()源码如下：

public final long incrementAndGet() {
    for (;;) {
        // 获取AtomicLong当前对应的long值
        long current = get();
        // 将current加1
        long next = current + 1;
        // 通过CAS函数，更新current的值
        if (compareAndSet(current, next))
            return next;
    }
}

说明：

incrementAndGet()首先会根据get()获取AtomicLong对应的long值。该值是volatile类型的变量，get()的源码如下：

// value是AtomicLong对应的long值
private volatile long value;
// 返回AtomicLong对应的long值
public final long get() {
    return value;
}

incrementAndGet()接着将current加1,然后通过CAS函数，将新的值赋值给value。
compareAndSet()的源码如下：

public final boolean compareAndSet(long expect, long update) {
    return unsafe.compareAndSwapLong(this, valueOffset, expect, update);
}

compareAndSet()的作用是更新AtomicLong对应的long值。它会比较AtomicLong的原始值是否与expect相等，若相等的话，则设置AtomicLong的值为update。

AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray

AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray这3个数组类型的原子类的原理和用法相似。本章以AtomicLongArray对数组类型的原子类进行介绍。

AtomicLongArray的作用则是对"长整形数组"进行原子操作。

public class AtomicLongArray implements java.io.Serializable {
	// 创建给定长度的新 AtomicLongArray。
	AtomicLongArray(int length)
	// 创建与给定数组具有相同长度的新 AtomicLongArray，并从给定数组复制其所有元素。
	AtomicLongArray(long[] array)
	
	// 以原子方式将给定值添加到索引 i 的元素。
	long addAndGet(int i, long delta)
	// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
	boolean compareAndSet(int i, long expect, long update)
	// 以原子方式将索引 i 的元素减1。
	long decrementAndGet(int i)
	// 获取位置 i 的当前值。
	long get(int i)
	// 以原子方式将给定值与索引 i 的元素相加。
	long getAndAdd(int i, long delta)
	// 以原子方式将索引 i 的元素减 1。
	long getAndDecrement(int i)
	// 以原子方式将索引 i 的元素加 1。
	long getAndIncrement(int i)
	// 以原子方式将位置 i 的元素设置为给定值，并返回旧值。
	long getAndSet(int i, long newValue)
	// 以原子方式将索引 i 的元素加1。
	long incrementAndGet(int i)
	// 最终将位置 i 的元素设置为给定值。
	void lazySet(int i, long newValue)
	// 返回该数组的长度。
	int length()
	// 将位置 i 的元素设置为给定值。
	void set(int i, long newValue)
	// 返回数组当前值的字符串表示形式。
	String toString()
	// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
	boolean    weakCompareAndSet(int i, long expect, long update)
}

AtomicLongArray的代码很简单，下面仅以incrementAndGet()为例，对AtomicLongArray的原理进行说明。
incrementAndGet()源码如下：

//incrementAndGet()的作用是以原子方式将long数组的索引 i 的元素加1，并返回加1之后的值。
public final long incrementAndGet(int i) {
    return addAndGet(i, 1);
}

addAndGet()源码如下：

public long addAndGet(int i, long delta) {
    // 检查数组是否越界
    long offset = checkedByteOffset(i);
    while (true) {
        // 获取long型数组的索引 offset 的原始值
        long current = getRaw(offset);
        // 修改long型值
        long next = current + delta;
        // 通过CAS更新long型数组的索引 offset的值。
        if (compareAndSetRaw(offset, current, next))
            return next;
    }
}

说明：addAndGet()首先检查数组是否越界。如果没有越界的话，则先获取数组索引i的值；然后通过CAS函数更新i的值。

getRaw()源码如下:

private long getRaw(long offset) {
    return unsafe.getLongVolatile(array, offset);
}

说明：unsafe是通过Unsafe.getUnsafe()返回的一个Unsafe对象。通过Unsafe的CAS函数对long型数组的元素进行原子操作。如compareAndSetRaw()就是调用Unsafe的CAS函数，它的源码如下：

private boolean compareAndSetRaw(long offset, long expect, long update) {
    return unsafe.compareAndSwapLong(array, offset, expect, update);
}

AtomicReference

AtomicReference是作用是对"对象"进行原子操作。

public class AtomicReference<V> implements java.io.Serializable {
	// 使用 null 初始值创建新的 AtomicReference。
	AtomicReference()
	// 使用给定的初始值创建新的 AtomicReference。
	AtomicReference(V initialValue)
	
	// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
	boolean compareAndSet(V expect, V update)
	// 获取当前值。
	V get()
	// 以原子方式设置为给定值，并返回旧值。
	V getAndSet(V newValue)
	// 最终设置为给定值。
	void lazySet(V newValue)
	// 设置为给定值。
	void set(V newValue)
	// 返回当前值的字符串表示形式。
	String toString()
	// 如果当前值 == 预期值，则以原子方式将该值设置为给定的更新值。
	boolean weakCompareAndSet(V expect, V update)
}

public class AtomicReference<V>  implements java.io.Serializable {
    private static final long serialVersionUID = -1848883965231344442L;

    // 获取Unsafe对象，Unsafe的作用是提供CAS操作
    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final long valueOffset;

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

    // volatile类型
    private volatile V value;

    public AtomicReference(V initialValue) {
        value = initialValue;
    }

    public AtomicReference() {
    }

    public final V get() {
        return value;
    }

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

    public final void lazySet(V newValue) {
        unsafe.putOrderedObject(this, valueOffset, newValue);
    }

    public final boolean compareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

    public final boolean weakCompareAndSet(V expect, V update) {
        return unsafe.compareAndSwapObject(this, valueOffset, expect, update);
    }

    public final V getAndSet(V newValue) {
        while (true) {
            V x = get();
            if (compareAndSet(x, newValue))
                return x;
        }
    }

    public String toString() {
        return String.valueOf(get());
    }
}

说明：
AtomicReference的源码比较简单。它是通过"volatile"和"Unsafe提供的CAS函数实现"原子操作。

value是volatile类型。这保证了：当某线程修改value的值时，其他线程看到的value值都是最新的value值，即修改之后的volatile的值。
通过CAS设置value。这保证了：当某线程池通过CAS函数(如compareAndSet函数)设置value时，它的操作是原子的，即线程在操作value时不会被中断。

// AtomicReferenceTest.java的源码
import java.util.concurrent.atomic.AtomicReference;

public class AtomicReferenceTest {
    
    public static void main(String[] args){

        // 创建两个Person对象，它们的id分别是101和102。
        Person p1 = new Person(101);
        Person p2 = new Person(102);
        // 新建AtomicReference对象，初始化它的值为p1对象
        AtomicReference ar = new AtomicReference(p1);
        // 通过CAS设置ar。如果ar的值为p1的话，则将其设置为p2。
        ar.compareAndSet(p1, p2);

        Person p3 = (Person)ar.get();
        System.out.println("p3 is "+p3);
        System.out.println("p3.equals(p1)="+p3.equals(p1));
    }
}

class Person {
    volatile long id;
    public Person(long id) {
        this.id = id;
    }
    public String toString() {
        return "id:"+id;
    }
}

运行结果：

p3 is id:102
p3.equals(p1)=false

结果说明：
新建AtomicReference对象ar时，将它初始化为p1。
紧接着，通过CAS函数对它进行设置。如果ar的值为p1的话，则将其设置为p2。
最后，获取ar对应的对象，并打印结果。p3.equals(p1)的结果为false，这是因为Person并没有覆盖equals()方法，而是采用继承自Object.java的equals()方法；而Object.java中的equals()实际上是调用"=="去比较两个对象，即比较两个对象的地址是否相等。

AtomicIntegerFieldUpdater, AtomicLongFieldUpdater,AtomicReferenceFieldUpdater

AtomicIntegerFieldUpdater, AtomicLongFieldUpdater和AtomicReferenceFieldUpdater这3个修改类的成员的原子类型的原理和用法相似。本章以对基本类型的原子类进行介绍。

AtomicLongFieldUpdater可以对指定"类的 'volatile long’类型的成员"进行原子更新。它是基于反射原理实现的。

public abstract class AtomicLongFieldUpdater<T> {
	// 受保护的无操作构造方法，供子类使用。
	protected AtomicLongFieldUpdater()
	
	// 以原子方式将给定值添加到此更新器管理的给定对象的字段的当前值。
	long addAndGet(T obj, long delta)
	// 如果当前值 == 预期值，则以原子方式将此更新器所管理的给定对象的字段设置为给定的更新值。
	abstract boolean compareAndSet(T obj, long expect, long update)
	// 以原子方式将此更新器管理的给定对象字段当前值减 1。
	long decrementAndGet(T obj)
	// 获取此更新器管理的在给定对象的字段中保持的当前值。
	abstract long get(T obj)
	// 以原子方式将给定值添加到此更新器管理的给定对象的字段的当前值。
	long getAndAdd(T obj, long delta)
	// 以原子方式将此更新器管理的给定对象字段当前值减 1。
	long getAndDecrement(T obj)
	// 以原子方式将此更新器管理的给定对象字段的当前值加 1。
	long getAndIncrement(T obj)
	// 将此更新器管理的给定对象的字段以原子方式设置为给定值，并返回旧值。
	long getAndSet(T obj, long newValue)
	// 以原子方式将此更新器管理的给定对象字段当前值加 1。
	long incrementAndGet(T obj)
	// 最后将此更新器管理的给定对象的字段设置为给定更新值。
	abstract void lazySet(T obj, long newValue)
	// 为对象创建并返回一个具有给定字段的更新器。
	static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName)
	// 将此更新器管理的给定对象的字段设置为给定更新值。
	abstract void set(T obj, long newValue)
	// 如果当前值 == 预期值，则以原子方式将此更新器所管理的给定对象的字段设置为给定的更新值。
	abstract boolean weakCompareAndSet(T obj, long expect, long update)
}

// LongTest.java的源码
import java.util.concurrent.atomic.AtomicLongFieldUpdater;

public class LongFieldTest {
    
    public static void main(String[] args) {

        // 获取Person的class对象
        Class cls = Person.class; 
        // 新建AtomicLongFieldUpdater对象，传递参数是“class对象”和“long类型在类中对应的名称”
        AtomicLongFieldUpdater mAtoLong = AtomicLongFieldUpdater.newUpdater(cls, "id");
        Person person = new Person(12345678L);

        // 比较person的"id"属性，如果id的值为12345678L，则设置为1000。
        mAtoLong.compareAndSet(person, 12345678L, 1000);
        System.out.println("id="+person.getId());
    }
}

class Person {
    volatile long id;
    public Person(long id) {
        this.id = id;
    }
    public void setId(long id) {
        this.id = id;
    }
    public long getId() {
        return id;
    }
}

运行结果：

id=1000

会走的桃子

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JUC原子类

文章目录数据类型AtomicInteger, AtomicLong, AtomicBooleanAtomicIntegerArray, AtomicLongArray, AtomicReferenceArray数据类型根据修改的数据类型，可以将JUC包中的原子操作类可以分为4类。基本类型: AtomicInteger, AtomicLong, AtomicBoolean ;数组类型: A...
复制链接

扫一扫

专栏目录