源碼剖解之sun.misc.Unsafe

首先介紹一下什麼是Compare And Swap(CAS)？簡單的說就是比較並交換。 　　CAS 操做包含三個操做數 —— 內存位置（V）、預期原值（A）和新值(B)。若是內存位置的值與預期原值相匹配，那麼處理器會自動將該位置值更新爲新值。不然，處理器不作任何操做。不管哪一種狀況，它都會在 CAS 指令以前返回該位置的值。CAS 有效地說明了「我認爲位置 V 應該包含值 A；若是包含該值，則將 B 放到這個位置；不然，不要更改該位置，只告訴我這個位置如今的值便可。」 Java併發包(java.util.concurrent)中大量使用了CAS操做,涉及到併發的地方都調用了sun.misc.Unsafe類方法進行CAS操做。 　　在看一下volatile,Volatile修飾的成員變量在每次被線程訪問時，都強迫從共享內存中重讀該成員變量的值。並且，當成員變量發生變化時，強迫線程將變化值回寫到共享內存。這樣在任什麼時候刻，兩個不一樣的線程老是看到某個成員變量的值是相同的，更簡單一點理解就是volatile修飾的變量值發生變化時對於另外的線程是可見的。 　　如何正確使用volatile能夠參考下面這篇文章： 　　Java 理論與實踐: 正確使用 Volatile 變量 　　下面來看看java中具體的CAS操做類sun.misc.Unsafe。Unsafe類提供了硬件級別的原子操做，Java沒法直接訪問到操做系統底層（如系統硬件等)，爲此Java使用native方法來擴展Java程序的功能。具體實現使用c++,詳見文件su();sun.misc包的源代碼能夠在這裏找到：

//下面是sun.misc.Unsafe.java類源碼
package sun.misc;
import java.lang.reflect.Field;
/***
* This class should provide access to low-level operations and its
* use should be limited to trusted code. Fields can be accessed using
* memory addresses, with undefined behaviour occurring if invalid memory
* addresses are given.
* 這個類提供了一個更底層的操做而且應該在受信任的代碼中使用。能夠經過內存地址
* 存取fields,若是給出的內存地址是無效的那麼會有一個不肯定的運行表現。
* 
* @author Tom Tromey ()
* @author Andrew John Hughes (gnu_andrew@membe)
*/
public class Unsafe
{
// Singleton class.
private static Unsafe unsafe = new Unsafe();
　　/***
　 * Private default constructor to prevent creation of an arbitrary
　 * number of instances.
　 * 使用私有默認構造器防止建立多個實例
　 */
private Unsafe()
{
}
　　/***
　 * Retrieve the singleton instance of <code>Unsafe</code>. The calling
　 * method should guard this instance from untrusted code, as it provides
　 * access to low-level operations such as direct memory access.
　 * 獲取<code>Unsafe</code>的單例,這個方法調用應該防止在不可信的代碼中實例，
　 * 由於unsafe類提供了一個低級別的操做，例如直接內存存取。
　 * 
　 * @throws SecurityException if a security manager exists and prevents
　 *　　　　　　　　　　　　　 access to the system properties.
　 *　　　　　　　　　　　　　 若是安全管理器不存在或者禁止訪問系統屬性
　 */
public static Unsafe getUnsafe()
{
　 SecurityManager sm = System.getSecurityManager();
　 if (sm != null)
　　 sm.checkPropertiesAccess();
　 return unsafe;
}

/***
　 * Returns the memory address offset of the given static field.
　 * The offset is merely used as a means to access a particular field
　 * in the other methods of this class. The value is unique to the given
　 * field and the same value should be returned on each subsequent call.
　 * 返回指定靜態field的內存地址偏移量,在這個類的其餘方法中這個值只是被用做一個訪問
　 * 特定field的一個方式。這個值對於 給定的field是惟一的，而且後續對該方法的調用都應該
　 * 返回相同的值。
　 *
　 * @param field the field whose offset should be returned.
　 *　　　　　　 須要返回偏移量的field
　 * @return the offset of the given field.
　 *　　　　 指定field的偏移量
　 */
public native long objectFieldOffset(Field field);
　　/***
　 * Compares the value of the integer field at the specified offset
　 * in the supplied object with the given expected value, and updates
　 * it if they match. The operation of this method should be atomic,
　 * thus providing an uninterruptible way of updating an integer field.
　 * 在obj的offset位置比較integer field和指望的值，若是相同則更新。這個方法
　 * 的操做應該是原子的，所以提供了一種不可中斷的方式更新integer field。
　 * 
　 * @param obj the object containing the field to modify.
　 *　　　　　 包含要修改field的對象
　 * @param offset the offset of the integer field within <code>obj</code>.
　 *　　　　　　　 <code>obj</code>中整型field的偏移量
　 * @param expect the expected value of the field.
　 *　　　　　　　 但願field中存在的值
　 * @param update the new value of the field if it equals <code>expect</code>.
　 * 　　　　 若是指望值expect與field的當前值相同，設置filed的值爲這個新值
　 * @return true if the field was changed.
　 * 　　　　　　　　　　　　　 若是field的值被更改
　 */
public native boolean compareAndSwapInt(Object obj, long offset,
　　　　　　　　　　　　　　　　　　　　 int expect, int update);
　　/***
　 * Compares the value of the long field at the specified offset
　 * in the supplied object with the given expected value, and updates
　 * it if they match. The operation of this method should be atomic,
　 * thus providing an uninterruptible way of updating a long field.
　 * 在obj的offset位置比較long field和指望的值，若是相同則更新。這個方法
　 * 的操做應該是原子的，所以提供了一種不可中斷的方式更新long field。
　 * 
　 * @param obj the object containing the field to modify.
　 * 　　　　　　 包含要修改field的對象 
　 * @param offset the offset of the long field within <code>obj</code>.
　 *　　　　　　　 <code>obj</code>中long型field的偏移量
　 * @param expect the expected value of the field.
　 *　　　　　　　 但願field中存在的值
　 * @param update the new value of the field if it equals <code>expect</code>.
　 *　　　　　　　 若是指望值expect與field的當前值相同，設置filed的值爲這個新值
　 * @return true if the field was changed.
　 *　　　　　　 若是field的值被更改
　 */
public native boolean compareAndSwapLong(Object obj, long offset,
　　　　　　　　　　　　　　　　　　　　　 long expect, long update);
　　/***
　 * Compares the value of the object field at the specified offset
　 * in the supplied object with the given expected value, and updates
　 * it if they match. The operation of this method should be atomic,
　 * thus providing an uninterruptible way of updating an object field.
　 * 在obj的offset位置比較object field和指望的值，若是相同則更新。這個方法
　 * 的操做應該是原子的，所以提供了一種不可中斷的方式更新object field。
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含要修改field的對象 
　 * @param offset the offset of the object field within <code>obj</code>.
　 *　 　　 <code>obj</code>中object型field的偏移量
　 * @param expect the expected value of the field.
　 *　　　　　　　 但願field中存在的值
　 * @param update the new value of the field if it equals <code>expect</code>.
　 *　　　　　　　 若是指望值expect與field的當前值相同，設置filed的值爲這個新值
　 * @return true if the field was changed.
　 *　　　　　　 若是field的值被更改
　 */
public native boolean compareAndSwapObject(Object obj, long offset,
　　　　　　　　　　　　　　　　　　　　　　 Object expect, Object update);
　　/***
　 * Sets the value of the integer field at the specified offset in the
　 * supplied object to the given value. This is an ordered or lazy
　 * version of <code>putIntVolatile(Object,long,int)</code>, which
　 * doesn't guarantee the immediate visibility of the change to other
　 * threads. It is only really useful where the integer field is
　 * <code>volatile</code>, and is thus expected to change unexpectedly.
　 * 設置obj對象中offset偏移地址對應的整型field的值爲指定值。這是一個有序或者
　 * 有延遲的<code>putIntVolatile</cdoe>方法，而且不保證值的改變被其餘線程立
　 * 即看到。只有在field被<code>volatile</code>修飾而且指望被意外修改的時候
　 * 使用纔有用。
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the integer field within <code>obj</code>.
　 * 　　 <code>obj</code>中整型field的偏移量
　 * @param value the new value of the field.
　 * 　　 field將被設置的新值
　 * @see #putIntVolatile(Object,long,int)
　 */
public native void putOrderedInt(Object obj, long offset, int value);
　　/***
　 * Sets the value of the long field at the specified offset in the
　 * supplied object to the given value. This is an ordered or lazy
　 * version of <code>putLongVolatile(Object,long,long)</code>, which
　 * doesn't guarantee the immediate visibility of the change to other
　 * threads. It is only really useful where the long field is
　 * <code>volatile</code>, and is thus expected to change unexpectedly.
　 * 設置obj對象中offset偏移地址對應的long型field的值爲指定值。這是一個有序或者
　 * 有延遲的<code>putLongVolatile</cdoe>方法，而且不保證值的改變被其餘線程立
　 * 即看到。只有在field被<code>volatile</code>修飾而且指望被意外修改的時候
　 * 使用纔有用。
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the long field within <code>obj</code>.
　 * 　　 <code>obj</code>中long型field的偏移量
　 * @param value the new value of the field.
　 * 　　 field將被設置的新值
　 * @see #putLongVolatile(Object,long,long)
　 */
public native void putOrderedLong(Object obj, long offset, long value);
　　/***
　 * Sets the value of the object field at the specified offset in the
　 * supplied object to the given value. This is an ordered or lazy
　 * version of <code>putObjectVolatile(Object,long,Object)</code>, which
　 * doesn't guarantee the immediate visibility of the change to other
　 * threads. It is only really useful where the object field is
　 * <code>volatile</code>, and is thus expected to change unexpectedly.
　 * 設置obj對象中offset偏移地址對應的object型field的值爲指定值。這是一個有序或者
　 * 有延遲的<code>putObjectVolatile</cdoe>方法，而且不保證值的改變被其餘線程立
　 * 即看到。只有在field被<code>volatile</code>修飾而且指望被意外修改的時候
　 * 使用纔有用。
　 *
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the object field within <code>obj</code>.
　 * 　　 <code>obj</code>中long型field的偏移量
　 * @param value the new value of the field.
　 * 　　 field將被設置的新值
　 */
public native void putOrderedObject(Object obj, long offset, Object value);
　　/***
　 * Sets the value of the integer field at the specified offset in the
　 * supplied object to the given value, with volatile store semantics.
　 * 設置obj對象中offset偏移地址對應的整型field的值爲指定值。支持volatile store語義
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the integer field within <code>obj</code>.
　 * 　　 <code>obj</code>中整型field的偏移量
　 * @param value the new value of the field.
　 * 　　 field將被設置的新值
　 */
public native void putIntVolatile(Object obj, long offset, int value);
　　/***
　 * Retrieves the value of the integer field at the specified offset in the
　 * supplied object with volatile load semantics.
　 * 獲取obj對象中offset偏移地址對應的整型field的值,支持volatile load語義。
　 * 
　 * @param obj the object containing the field to read.
　 * 　 包含須要去讀取的field的對象
　 * @param offset the offset of the integer field within <code>obj</code>.
　 * 　　 <code>obj</code>中整型field的偏移量
　 */
public native int getIntVolatile(Object obj, long offset);
　　/***
　 * Sets the value of the long field at the specified offset in the
　 * supplied object to the given value, with volatile store semantics.
　 * 設置obj對象中offset偏移地址對應的long型field的值爲指定值。支持volatile store語義
　 *
　 * @param obj the object containing the field to modify.
　 *　　　　　 包含須要修改field的對象
　 * @param offset the offset of the long field within <code>obj</code>.
　 *　　　　　　　 <code>obj</code>中long型field的偏移量
　 * @param value the new value of the field.
　 *　　　　　　 field將被設置的新值
　 * @see #putLong(Object,long,long)
　 */
public native void putLongVolatile(Object obj, long offset, long value);
　　/***
　 * Sets the value of the long field at the specified offset in the
　 * supplied object to the given value.
　 * 設置obj對象中offset偏移地址對應的long型field的值爲指定值。
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the long field within <code>obj</code>.
　 * 　　<code>obj</code>中long型field的偏移量
　 * @param value the new value of the field.
　 * 　　field將被設置的新值
　 * @see #putLongVolatile(Object,long,long)
　 */
public native void putLong(Object obj, long offset, long value);
　　/***
　 * Retrieves the value of the long field at the specified offset in the
　 * supplied object with volatile load semantics.
　 * 獲取obj對象中offset偏移地址對應的long型field的值,支持volatile load語義。
　 * 
　 * @param obj the object containing the field to read.
　 * 　 包含須要去讀取的field的對象
　 * @param offset the offset of the long field within <code>obj</code>.
　 * 　　 <code>obj</code>中long型field的偏移量
　 * @see #getLong(Object,long)
　 */
public native long getLongVolatile(Object obj, long offset);
　　/***
　 * Retrieves the value of the long field at the specified offset in the
　 * supplied object.
　 * 獲取obj對象中offset偏移地址對應的long型field的值
　 * 
　 * @param obj the object containing the field to read.
　 * 　 包含須要去讀取的field的對象
　 * @param offset the offset of the long field within <code>obj</code>.
　 * 　　 <code>obj</code>中long型field的偏移量
　 * @see #getLongVolatile(Object,long)
　 */
public native long getLong(Object obj, long offset);
　　/***
　 * Sets the value of the object field at the specified offset in the
　 * supplied object to the given value, with volatile store semantics.
　 * 設置obj對象中offset偏移地址對應的object型field的值爲指定值。支持volatile store語義
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the object field within <code>obj</code>.
　 * 　　<code>obj</code>中object型field的偏移量
　 * @param value the new value of the field.
　 * 　　 field將被設置的新值
　 * @see #putObject(Object,long,Object)
　 */
public native void putObjectVolatile(Object obj, long offset, Object value);
　　/***
　 * Sets the value of the object field at the specified offset in the
　 * supplied object to the given value.
　 * 設置obj對象中offset偏移地址對應的object型field的值爲指定值。
　 * 
　 * @param obj the object containing the field to modify.
　 * 　 包含須要修改field的對象
　 * @param offset the offset of the object field within <code>obj</code>.
　 * 　　<code>obj</code>中object型field的偏移量
　 * @param value the new value of the field.
　 * 　　 field將被設置的新值
　 * @see #putObjectVolatile(Object,long,Object)
　 */
public native void putObject(Object obj, long offset, Object value);
　　/***
　 * Retrieves the value of the object field at the specified offset in the
　 * supplied object with volatile load semantics.
　 * 獲取obj對象中offset偏移地址對應的object型field的值,支持volatile load語義。
　 * 
　 * @param obj the object containing the field to read.
　 * 　 包含須要去讀取的field的對象
　 * @param offset the offset of the object field within <code>obj</code>.
　 * 　　 <code>obj</code>中object型field的偏移量
　 */
public native Object getObjectVolatile(Object obj, long offset);
　　/***
　 * Returns the offset of the first element for a given array class.
　 * To access elements of the array class, this value may be used along with
　 * with that returned by 
　 * <a #arrayIndexScale"$amp;>amp;$lt;code>arrayIndexScale</code$amp;>amp;$lt;/a>,
　 * if non-zero.
　 * 獲取給定數組中第一個元素的偏移地址。
　 * 爲了存取數組中的元素，這個偏移地址與<a #arrayIndexScale"$amp;>amp;$lt;code>arrayIndexScale
　 * </code$amp;>amp;$lt;/a>方法的非0返回值一塊兒被使用。
　 * @param arrayClass the class for which the first element's address should
　 *　　　　　　　　　 be obtained.
　 *　　　　　　　　　 第一個元素地址被獲取的class
　 * @return the offset of the first element of the array class.
　 * 　 數組第一個元素 的偏移地址
　 * @see arrayIndexScale(Class)
　 */
public native int arrayBaseOffset(Class arrayClass);
　　/***
　 * Returns the scale factor used for addressing elements of the supplied
　 * array class. Where a suitable scale factor can not be returned (e.g.
　 * for primitive types), zero should be returned. The returned value
　 * can be used with 
　 * <a #arrayBaseOffset"$amp;>amp;$lt;code>arrayBaseOffset</code$amp;>amp;$lt;/a>
　 * to access elements of the class.
　 * 獲取用戶給定數組尋址的換算因子.一個合適的換算因子不能返回的時候(例如：基本類型),
　 * 返回0.這個返回值可以與<a #arrayBaseOffset"$amp;>amp;$lt;code>arrayBaseOffset</code>
　 * </a>一塊兒使用去存取這個數組class中的元素
　 * 
　 * @param arrayClass the class whose scale factor should be returned.
　 * @return the scale factor, or zero if not supported for this array class.
　 */
public native int arrayIndexScale(Class arrayClass);

/***
　 * Releases the block on a thread created by 
　 * <a #park"$amp;>amp;$lt;code>park</code$amp;>amp;$lt;/a>. This method can also be used
　 * to terminate a blockage caused by a prior call to <code>park</code>.
　 * This operation is unsafe, as the thread must be guaranteed to be
　 * live. This is true of Java, but not native code.
　 * 釋放被<a #park"$amp;>amp;$lt;code>park</code$amp;>amp;$lt;/a>建立的在一個線程上的阻塞.這個
　 * 方法也能夠被使用來終止一個先前調用<code>park</code>致使的阻塞.
　 * 這個操做操做時不安全的,所以線程必須保證是活的.這是java代碼不是native代碼。
　 * @param thread the thread to unblock.
　 * 　　　　 要解除阻塞的線程
　 */
public native void unpark(Thread thread);
　　/***
　 * Blocks the thread until a matching 
　 * <a #unpark"$amp;>amp;$lt;code>unpark</code$amp;>amp;$lt;/a> occurs, the thread is
　 * interrupted or the optional timeout expires. If an <code>unpark</code>
　 * call has already occurred, this also counts. A timeout value of zero
　 * is defined as no timeout. When <code>isAbsolute</code> is
　 * <code>true</code>, the timeout is in milliseconds relative to the
　 * epoch. Otherwise, the value is the number of nanoseconds which must
　 * occur before timeout. This call may also return spuriously (i.e.
　 * for no apparent reason).
　 * 阻塞一個線程直到<a #unpark"$amp;>amp;$lt;code>unpark</code$amp;>amp;$lt;/a>出現、線程
　 * 被中斷或者timeout時間到期。若是一個<code>unpark</code>調用已經出現了，
　 * 這裏只計數。timeout爲0表示永不過時.當<code>isAbsolute</code>爲true時，
　 * timeout是相對於新紀元以後的毫秒。不然這個值就是超時前的納秒數。這個方法執行時
　 * 也可能不合理地返回(沒有具體緣由)
　 * 
　 * @param isAbsolute true if the timeout is specified in milliseconds from
　 *　　　　　　　　　 the epoch.
　 *　　　　　　　　　 若是爲true timeout的值是一個相對於新紀元以後的毫秒數
　 * @param time either the number of nanoseconds to wait, or a time in
　 *　　　　　　 milliseconds from the epoch to wait for.
　 *　　　　　　 能夠是一個要等待的納秒數，或者是一個相對於新紀元以後的毫秒數直到
　 *　　　　　　 到達這個時間點
　 */
public native void park(boolean isAbsolute, long time);
}

　　//下面是su源碼
　　#include <gcj/cni.h>
　　#include <gcj/field.h>
　　#include <gcj/javaprims.h>
　　#include <jvm.h>
　　#include <sun/misc/Unsafe.h>
　　#include <java/lang/System.h>
　　#include <java/lang/InterruptedException.h>
　　#include <java/lang/Thread.h>
　　#include <java/lang/Long.h>
　　#include "sysdep/locks.h"
　　// Use a spinlock for multi-word accesses
　　class spinlock
　　{
　　static volatile obj_addr_t lock;
　　public:
　　spinlock ()
　　{
　　while (! compare_and_swap (&lock, 0, 1))
　　_Jv_ThreadYield ();
　　}
　　~spinlock ()
　　{
　　release_set (&lock, 0);
　　}
　　};
　　// This is a single lock that is used for all synchronized accesses if
　　// the compiler can't generate inline compare-and-swap operations. In
　　// most cases it'll never be used, but the i386 needs it for 64-bit
　　// locked accesses and so does PPC32. It's worth building libgcj with
　　// target=i486 (or above) to get the inlines.
　　volatile obj_addr_t spinlock::lock;
　　static inline bool
　　compareAndSwap (volatile jint *addr, jint old, jint new_val)
　　{
　　jboolean result = false;
　　spinlock lock;
　　if ((result = (*addr == old)))
　　*addr = new_val;
　　return result;
　　}
　　static inline bool
　　compareAndSwap (volatile jlong *addr, jlong old, jlong new_val)
　　{
　　jboolean result = false;
　　spinlock lock;
　　if ((result = (*addr == old)))
　　*addr = new_val;
　　return result;
　　}
　　static inline bool
　　compareAndSwap (volatile jobject *addr, jobject old, jobject new_val)
　　{
　　jboolean result = false;
　　spinlock lock;
　　if ((result = (*addr == old)))
　　*addr = new_val;
　　return result;
　　}
　　jlong
　　sun::misc::Unsafe::objectFieldOffset (::java::lang::reflect::Field *field)
　　{
　　_Jv_Field *fld = _Jv_FromReflectedField (field);
　　// FIXME: what if it is not an instance field
　　return fld->getOffset();
　　}
　　jint
　　sun::misc::Unsafe::arrayBaseOffset (jclass arrayClass)
　　{
　　// FIXME: assert that arrayClass is array.
　　jclass eltClass = arrayClass->getComponentType();
　　return (jint)(jlong) _Jv_GetArrayElementFromElementType (NULL, eltClass);
　　}
　　jint
　　sun::misc::Unsafe::arrayIndexScale (jclass arrayClass)
　　{
　　// FIXME: assert that arrayClass is array.
　　jclass eltClass = arrayClass->getComponentType();
　　if (eltClass->isPrimitive())
　　return eltClass->size();
　　return sizeof (void *);
　　}
　　// These methods are used when the compiler fails to generate inline
　　// versions of the compare-and-swap primitives.
　　jboolean
　　sun::misc::Unsafe::compareAndSwapInt (jobject obj, jlong offset,
　　jint expect, jint update)
　　{
　　jint *addr = (jint *)((char *)obj + offset);
　　return compareAndSwap (addr, expect, update);
　　}
　　jboolean
　　sun::misc::Unsafe::compareAndSwapLong (jobject obj, jlong offset,
　　jlong expect, jlong update)
　　{
　　volatile jlong *addr = (jlong*)((char *) obj + offset);
　　return compareAndSwap (addr, expect, update);
　　}
　　jboolean
　　sun::misc::Unsafe::compareAndSwapObject (jobject obj, jlong offset,
　　jobject expect, jobject update)
　　{
　　jobject *addr = (jobject*)((char *) obj + offset);
　　return compareAndSwap (addr, expect, update);
　　}
　　void
　　sun::misc::Unsafe::putOrderedInt (jobject obj, jlong offset, jint value)
　　{
　　volatile jint *addr = (jint *) ((char *) obj + offset);
　　*addr = value;
　　}
　　void
　　sun::misc::Unsafe::putOrderedLong (jobject obj, jlong offset, jlong value)
　　{
　　volatile jlong *addr = (jlong *) ((char *) obj + offset);
　　spinlock lock;
　　*addr = value;
　　}
　　void
　　sun::misc::Unsafe::putOrderedObject (jobject obj, jlong offset, jobject value)
　　{
　　volatile jobject *addr = (jobject *) ((char *) obj + offset);
　　*addr = value;
　　}
　　void
　　sun::misc::Unsafe::putIntVolatile (jobject obj, jlong offset, jint value)
　　{
　　write_barrier ();
　　volatile jint *addr = (jint *) ((char *) obj + offset);
　　*addr = value;
　　}
　　void
　　sun::misc::Unsafe::putLongVolatile (jobject obj, jlong offset, jlong value)
　　{
　　volatile jlong *addr = (jlong *) ((char *) obj + offset);
　　spinlock lock;
　　*addr = value;
　　}
　　void
　　sun::misc::Unsafe::putObjectVolatile (jobject obj, jlong offset, jobject value)
　　{
　　write_barrier ();
　　volatile jobject *addr = (jobject *) ((char *) obj + offset);
　　*addr = value;
　　}
　　#if 0 // FIXME
　　void
　　sun::misc::Unsafe::putInt (jobject obj, jlong offset, jint value)
　　{
　　jint *addr = (jint *) ((char *) obj + offset);
　　*addr = value;
　　}
　　#endif
　　void
　　sun::misc::Unsafe::putLong (jobject obj, jlong offset, jlong value)
　　{
　　jlong *addr = (jlong *) ((char *) obj + offset);
　　spinlock lock;
　　*addr = value;
　　}
　　void
　　sun::misc::Unsafe::putObject (jobject obj, jlong offset, jobject value)
　　{
　　jobject *addr = (jobject *) ((char *) obj + offset);
　　*addr = value;
　　}
　　jint
　　sun::misc::Unsafe::getIntVolatile (jobject obj, jlong offset)
　　{
　　volatile jint *addr = (jint *) ((char *) obj + offset);
　　jint result = *addr;
　　read_barrier ();
　　return result;
　　}
　　jobject
　　sun::misc::Unsafe::getObjectVolatile (jobject obj, jlong offset)
　　{
　　volatile jobject *addr = (jobject *) ((char *) obj + offset);
　　jobject result = *addr;
　　read_barrier ();
　　return result;
　　}
　　jlong
　　sun::misc::Unsafe::getLong (jobject obj, jlong offset)
　　{
　　jlong *addr = (jlong *) ((char *) obj + offset);
　　spinlock lock;
　　return *addr;
　　}
　　jlong
　　sun::misc::Unsafe::getLongVolatile (jobject obj, jlong offset)
　　{
　　volatile jlong *addr = (jlong *) ((char *) obj + offset);
　　spinlock lock;
　　return *addr;
　　}
　　void
　　sun::misc::Unsafe::unpark (::java::lang::Thread *thread)
　　{
　　natThread *nt = (natThread *) thread->data;
　　nt->park_helper.unpark ();
　　}
　　void
　　sun::misc::Unsafe::park (jboolean isAbsolute, jlong time)
　　{
　　using namespace ::java::lang;
　　Thread *thread = Thread::currentThread();
　　natThread *nt = (natThread *) thread->data;
　　nt->park_helper.park (isAbsolute, time);
　　}

　　* 若是您有不一樣看法或發現錯誤，歡迎討論或指出。qq：294016299