Java线程--AtomicReference原子对象

AtomicReference<T>原子对象

AtomicReference<T>作用

是对”对象”T进行原子操作. 

AtomicReference<T>的源码剖析

public class AtomicReference<V> 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);


}