[Java多线程 七]---JUC包下原子类
来源:互联网 发布:淘宝解除手机号绑定 编辑:程序博客网 时间:2024/06/04 19:14
主要内容引自大神的博客:http://www.cnblogs.com/skywang12345/p/3514589.html
分类
原子类的类结构API
根据修改的数据类型,可以将JUC包中的原子操作类可以分为4类。
基本类型: AtomicInteger, AtomicLong, AtomicBoolean ;
数组类型: AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray ;
引用类型: AtomicReference, AtomicStampedRerence, AtomicMarkableReference ;
对象的属性修改类型: AtomicIntegerFieldUpdater, AtomicLongFieldUpdater, AtomicReferenceFieldUpdater 。
这些类存在的目的是对相应的数据进行原子操作。所谓原子操作,是指操作过程不会被中断,保证数据操作是以原子方式进行的。
多个线程执行一个操作时,其中任何一个线程要么完全执行完此操作,要么没有执行此操作的任何步骤,那么这个操作就是原子的。
出现原因: synchronized的代价比较高。
基本类型
AtomicInteger, AtomicLong和AtomicBoolean这3个基本类型的原子类的原理和用法相似。原子类并非不可变的,但它们应该是属于相对安全的类别本章以AtomicLong对基本类型的原子类进行介绍。
AtomicLong基本介绍
AtomicLong是作用是对长整形进行原子操作。在32位操作系统中,64位的long 和 double 变量由于会被JVM当作两个分离的32位来进行操作,所以不具有原子性。而使用AtomicLong能让long的操作保持原子型。
AtomicLong函数列表
// 构造函数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源码分析
AtomicLong的代码很简单,下面仅以incrementAndGet()为例,对AtomicLong的原理进行说明。
public final long incrementAndGet() { for (;;) { // 获取AtomicLong当前对应的long值 long current = get(); //得到的是返回的旧值 // 将current加1 long next = current + 1; // 通过CAS函数,更新current的值 if (compareAndSet(current, next)) //如果旧值和内存中的相等,则更新为新值 return next; }}
(1) incrementAndGet()首先会根据get()获取AtomicLong对应的long值。该值是volatile类型的变量,get()的源码如下:
// value是AtomicLong对应的long值private volatile long value;// 返回AtomicLong对应的long值public final long get() { return value;}
(2) 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。
int num = 0;void add(){ int temp; do { temp = num; } while (cas(num, temp, temp+1)==true)
我们看到用一个do while来无限判断cas的修改结果,如果修改完成,那就成功+1(修改不成功的原因是因为在获取V值后得到A值的时候如果有其它线程对V值操作,使得A与V不匹配,则cas失败,等待下一次cas),如果cas没有修改成功,继续while,temp将获取最新的num,再次cas操作!
AtomicLong示例
//LongTest.java的源码import java.util.concurrent.atomic.AtomicLong;public class LongTest { public static void main(String[] args){ // 新建AtomicLong对象 AtomicLong mAtoLong = new AtomicLong(); mAtoLong.set(0x0123456789ABCDEFL); System.out.printf("%20s : 0x%016X\n", "get()", mAtoLong.get()); System.out.printf("%20s : 0x%016X\n", "intValue()", mAtoLong.intValue()); System.out.printf("%20s : 0x%016X\n", "longValue()", mAtoLong.longValue()); System.out.printf("%20s : %s\n", "doubleValue()", mAtoLong.doubleValue()); System.out.printf("%20s : %s\n", "floatValue()", mAtoLong.floatValue()); System.out.printf("%20s : 0x%016X\n", "getAndDecrement()", mAtoLong.getAndDecrement()); System.out.printf("%20s : 0x%016X\n", "decrementAndGet()", mAtoLong.decrementAndGet()); System.out.printf("%20s : 0x%016X\n", "getAndIncrement()", mAtoLong.getAndIncrement()); System.out.printf("%20s : 0x%016X\n", "incrementAndGet()", mAtoLong.incrementAndGet()); System.out.printf("%20s : 0x%016X\n", "addAndGet(0x10)", mAtoLong.addAndGet(0x10)); System.out.printf("%20s : 0x%016X\n", "getAndAdd(0x10)", mAtoLong.getAndAdd(0x10)); System.out.printf("\n%20s : 0x%016X\n", "get()", mAtoLong.get()); System.out.printf("%20s : %s\n", "compareAndSet()", mAtoLong.compareAndSet(0x12345679L, 0xFEDCBA9876543210L)); System.out.printf("%20s : 0x%016X\n", "get()", mAtoLong.get()); }}
运行结果
get() : 0x0123456789ABCDEF intValue() : 0x0000000089ABCDEF longValue() : 0x0123456789ABCDEF doubleValue() : 8.1985529216486896E16 floatValue() : 8.1985531E16 getAndDecrement() : 0x0123456789ABCDEF decrementAndGet() : 0x0123456789ABCDED getAndIncrement() : 0x0123456789ABCDED incrementAndGet() : 0x0123456789ABCDEF addAndGet(0x10) : 0x0123456789ABCDFF getAndAdd(0x10) : 0x0123456789ABCDFF get() : 0x0123456789ABCE0F compareAndSet() : false //原始值不等于预期值,所以返回false get() : 0x0123456789ABCE0F
数组类型
AtomicIntegerArray, AtomicLongArray, AtomicReferenceArray这3个数组类型的原子类的原理和用法相似。本章以AtomicLongArray对数组类型的原子类进行介绍。
AtomicLongArray基本介绍
AtomicLong是作用是对长整形进行原子操作。而AtomicLongArray的作用则是对”长整形数组”进行原子操作。
AtomicLongArray函数列表
// 创建给定长度的新 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的源码分析
AtomicLongArray的代码很简单,下面仅以incrementAndGet()为例,对AtomicLong的原理进行说明。incrementAndGet()源码如下:
public final long incrementAndGet(int i) { return addAndGet(i, 1);}
说明:incrementAndGet()的作用是以原子方式将long数组的索引 i 的元素加1,并返回加1之后的值。
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);}
AtomicLongArray示例
// LongArrayTest.java的源码import java.util.concurrent.atomic.AtomicLongArray;public class LongArrayTest { public static void main(String[] args){ // 新建AtomicLongArray对象 long[] arrLong = new long[] {10, 20, 30, 40, 50}; AtomicLongArray ala = new AtomicLongArray(arrLong); ala.set(0, 100); for (int i=0, len=ala.length(); i<len; i++) System.out.printf("get(%d) : %s\n", i, ala.get(i)); System.out.printf("%20s : %s\n", "getAndDecrement(0)", ala.getAndDecrement(0)); System.out.printf("%20s : %s\n", "decrementAndGet(1)", ala.decrementAndGet(1)); System.out.printf("%20s : %s\n", "getAndIncrement(2)", ala.getAndIncrement(2)); System.out.printf("%20s : %s\n", "incrementAndGet(3)", ala.incrementAndGet(3)); System.out.printf("%20s : %s\n", "addAndGet(100)", ala.addAndGet(0, 100)); System.out.printf("%20s : %s\n", "getAndAdd(100)", ala.getAndAdd(1, 100)); System.out.printf("%20s : %s\n", "compareAndSet()", ala.compareAndSet(2, 31, 1000)); System.out.printf("%20s : %s\n", "get(2)", ala.get(2)); }}
运行结果
get(0) : 100get(1) : 20get(2) : 30get(3) : 40get(4) : 50getAndDecrement(0) : 100decrementAndGet(1) : 19getAndIncrement(2) : 30incrementAndGet(3) : 41addAndGet(100) : 199getAndAdd(100) : 19compareAndSet() : trueget(2) : 1000
引用类型
对AtomicReference引用类型的原子类进行介绍
AtomicReference基本介绍
AtomicReference是作用是对”对象”进行原子操作。
AtomicReference函数列表
// 使用 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)
AtomicReference源码分析
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函数实现”原子操作。
(01) value是volatile类型。这保证了:当某线程修改value的值时,其他线程看到的value值都是最新的value值,即修改之后的volatile的值。
(02) 通过CAS设置value。这保证了:当某线程池通过CAS函数(如compareAndSet函数)设置value时,它的操作是原子的,即线程在操作value时不会被中断。
AtomicReference示例
// 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:102p3.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这3个修改类的成员的原子类型的原理和用法相似。本章以对基本类型的原子类AtomicLongFieldUpdater进行介绍
AtomicLongFieldUpdater基本介绍
AtomicLongFieldUpdater可以对指定”类的 ‘volatile long’类型的成员”进行原子更新。它是基于反射原理实现的。
AtomicLongFieldUpdater函数列表
// 受保护的无操作构造方法,供子类使用。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)
AtomicLongFieldUpdater源码分析
下面分析LongFieldTest.java的流程。
* newUpdater() , newUpdater()的源码如下:*
public static <U> AtomicLongFieldUpdater<U> newUpdater(Class<U> tclass, String fieldName) { Class<?> caller = Reflection.getCallerClass(); if (AtomicLong.VM_SUPPORTS_LONG_CAS) return new CASUpdater<U>(tclass, fieldName, caller); else return new LockedUpdater<U>(tclass, fieldName, caller);}
说明:newUpdater()的作用是获取一个AtomicIntegerFieldUpdater类型的对象。它实际上返回的是CASUpdater对象,或者LockedUpdater对象;具体返回哪一个类取决于JVM是否支持long类型的CAS函数。CASUpdater和LockedUpdater都是AtomicIntegerFieldUpdater的子类,它们的实现类似。下面以CASUpdater来进行说明。
CASUpdater类的源码如下:
public boolean compareAndSet(T obj, long expect, long update) { if (obj == null || obj.getClass() != tclass || cclass != null) fullCheck(obj); return unsafe.compareAndSwapLong(obj, offset, expect, update);}
说明:它实际上是通过CAS函数操作。如果类的long对象的值是expect,则设置它的值为update。
AtomicLongFieldUpdater示例
// 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; }}
- [Java多线程 七]---JUC包下原子类
- [Java多线程 七]---JUC包下原子类
- JAVA多线程之JUC原子类
- Java多线程系列--“JUC原子类”
- Java多线程系列--【JUC原子类01】- AtomicLong原子类
- Java多线程系列--【JUC原子类02】- AtomicLongArray原子类
- Java多线程系列--【JUC原子类03】- AtomicReference原子类
- Java多线程系列--【JUC原子类04】- AtomicLongFieldUpdater原子类
- Java多线程系列--“JUC原子类”01之 框架
- Java多线程系列--“JUC原子类”01之 框架 (r)
- Java多线程系列--“JUC原子类”01之 框架
- Java多线程系列--“JUC原子类”02之 AtomicLong原子类
- Java多线程系列--“JUC原子类”03之 AtomicLongArray原子类
- Java多线程系列--“JUC原子类”04之 AtomicReference原子类
- Java多线程系列--“JUC原子类”05之 AtomicLongFieldUpdater原子类
- Java多线程系列--“JUC原子类”04之 AtomicReference原子类
- Java多线程系列--“JUC原子类”02之 AtomicLong原子类 (r)
- Java多线程系列--“JUC原子类”03之 AtomicLongArray原子类 (r)
- RMAN备份概念
- HDU
- hdu 1074 Doing Homework (状压dp)
- lib_A启动lib_B的activity即两个依赖工程互相启动组件
- 缓存淘汰算法--LRU算法
- [Java多线程 七]---JUC包下原子类
- Dubbo的简介
- MD5加密
- linux查看端口号使用情况
- vue单页应用项目加入百度统计代码
- 1-12运行结果参考
- 图论--tarjan求lca
- mysql:退出服务器
- [NOIP2017模拟]疯狂的01串