Java线程--AtomicReference原子对象
AtomicReference原子对象
AtomicReference
作用
是对”对象”T进行原子操作。
不使用引用变量，而是把对象存储在一个AtomicReference
除了AtomicReference
死记：多线程业务代码核心思想：
获得锁
临界区：原子操作：一组语句访问一组相关的状态变量
释放锁
AtomicReference
的源码剖析
public class AtomicReference implements Serializable {
private static final Unsafe unsafe = Unsafe.getUnsafe(); //unsafe 实现CAS原子操作
private volatile V value; //volatile可见性
public AtomicReference(V var1) {
this.value = var1;
}
/**
* 读：volatile变量，在读时能确保读到的始终是当前内存的最新值
*/
public final V get() {
return this.value;
}
/**
* 写：volatile变量，立即写回内存 并 保证其它cpu内的该值所在的缓存行无效(总线嗅探技术)
*/
public final V getAndSet(V var1) {
return unsafe.getAndSetObject(this, valueOffset, var1); //unsafe 实现原子操作
}
//.....省略.....
}
下面附上rt.jar包中的Unsafe类的部分源码：主要想表达java.util.concurrent包的灵魂：
/**
* volatile、CAS原理、自旋结构、组合在一起构成了java.util.concurrent包
*
* volatile：修饰的变量如果是对象或数组，是指对象或数组的地址具有可见性，但是数组或对象内部的成员改变不具备可见性
*
* CAS原理：lock前缀指令,执行该cas指令时会锁住缓冲行
*
*自旋结构：for(;;){ 读内存值; if(cas操作){return;} }
*/
package sun.misc;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.ProtectionDomain;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
/**
* volatile, CAS操作, 自旋结构 组合在一起构成了java.util.concurrent包
*
* volatile 修饰的变量如果是对象或数组，其含义是对象或数组的地址具有可见性，但是数组或对象内部的成员改变不具备可见性
*
* CAS操作; lock前缀指令,执行该cas指令时会锁住缓冲行
*
*自旋结构; for(;;){ 读内存值; if(cas操作){return;} }
*/
//Unsafe类在%JAVA_HOME%/jre/lib/rt.jar包中
public final class Unsafe
{
private static final Unsafe theUnsafe = new Unsafe();
public static final int INVALID_FIELD_OFFSET = -1;
/**
* 自旋结构：for(;;){ 读内存值; if(cas操作compareAndSwapObject){return;} }
* 参数 paramObject1 cpu旧值
* 参数 paramLong 偏移量
* 参数 paramObject2 cpu新值
*/
public final Object getAndSetObject(Object paramObject1, long paramLong, Object paramObject2)
{
Object localObject;
do
{
localObject = getObjectVolatile(paramObject1, paramLong);
} while (!compareAndSwapObject(paramObject1, paramLong, localObject, paramObject2));
return localObject;
}
//原子操作：比较并转换：cpu内旧值paramObject1, 偏移量paramLong, 内存当前值paramObject2, cpu内新值paramObject3
public final native boolean compareAndSwapObject(Object paramObject1, long paramLong, Object paramObject2, Object paramObject3);
//原子操作：读取可见性内存值
public native Object getObjectVolatile(Object paramObject, long paramLong);
/**
* 自旋结构：for(;;){ 读内存值; if(cas操作compareAndSwapInt){return;} }
* 参数 paramObject1 cpu旧值
* 参数 paramLong 偏移量
* 参数 paramInt 累加
*/
public final int getAndAddInt(Object paramObject, long paramLong, int paramInt)
{
int i;
do
{
i = getIntVolatile(paramObject, paramLong);
} while (!compareAndSwapInt(paramObject, paramLong, i, i + paramInt));
return i;
}
//原子操作：比较并转换：cpu内旧值paramObject1, 偏移量paramLong, 内存当前值paramObject2, cpu内新值paramObject3
public final native boolean compareAndSwapInt(Object paramObject, long paramLong, int paramInt1, int paramInt2);
public native int getIntVolatile(Object paramObject, long paramLong);
/**
* 自旋结构：for(;;){ 读内存值; if(cas操作compareAndSwapInt){return;} }
* 参数 paramObject cpu旧值
* 参数 paramLong 偏移量
* 参数 paramInt cpu新值
*/
public final int getAndSetInt(Object paramObject, long paramLong, int paramInt)
{
int i;
do
{
i = getIntVolatile(paramObject, paramLong);
} while (!compareAndSwapInt(paramObject, paramLong, i, paramInt));
return i;
}
public native void unpark(Object paramObject);
public native void park(boolean paramBoolean, long paramLong);
public void setMemory(long paramLong1, long paramLong2, byte paramByte)
{
setMemory(null, paramLong1, paramLong2, paramByte);
}
public void copyMemory(long paramLong1, long paramLong2, long paramLong3)
{
copyMemory(null, paramLong1, null, paramLong2, paramLong3);
}
public native void setMemory(Object paramObject, long paramLong1, long paramLong2, byte paramByte);
public native void copyMemory(Object paramObject1, long paramLong1, Object paramObject2, long paramLong2, long paramLong3);
}