Java中Unsafe類詳解

http://www.cnblogs.com/mickole/articles/3757278.html

Java不能直接通路作業系統底層，而是通過本地方法來通路。Unsafe類提供了硬體級别的原子操作，主要提供了以下功能：

1、通過Unsafe類可以配置設定記憶體，可以釋放記憶體；

類中提供的3個本地方法allocateMemory、reallocateMemory、freeMemory分别用于配置設定記憶體，擴充記憶體和釋放記憶體，與C語言中的3個方法對應。

public native long allocateMemory(long l);
public native long reallocateMemory(long l, long l1);
public native void freeMemory(long l);      

2、可以定位對象某字段的記憶體位置，也可以修改對象的字段值，即使它是私有的；

字段的定位：

JAVA中對象的字段的定位可能通過staticFieldOffset方法實作，該方法傳回給定field的記憶體位址偏移量，這個值對于給定的filed是唯一的且是固定不變的。

getIntVolatile方法擷取對象中offset偏移位址對應的整型field的值,支援volatile load語義。

getLong方法擷取對象中offset偏移位址對應的long型field的值

數組元素定位：

Unsafe類中有很多以BASE_OFFSET結尾的常量，比如ARRAY_INT_BASE_OFFSET，ARRAY_BYTE_BASE_OFFSET等，這些常量值是通過arrayBaseOffset方法得到的。arrayBaseOffset方法是一個本地方法，可以擷取數組第一個元素的偏移位址。Unsafe類中還有很多以INDEX_SCALE結尾的常量，比如 ARRAY_INT_INDEX_SCALE ， ARRAY_BYTE_INDEX_SCALE等，這些常量值是通過arrayIndexScale方法得到的。arrayIndexScale方法也是一個本地方法，可以擷取數組的轉換因子，也就是數組中元素的增量位址。将arrayBaseOffset與arrayIndexScale配合使用，可以定位數組中每個元素在記憶體中的位置。

public final class Unsafe {
    public static final int ARRAY_INT_BASE_OFFSET;
    public static final int ARRAY_INT_INDEX_SCALE;

    public native long staticFieldOffset(Field field);
    public native int getIntVolatile(Object obj, long l);
    public native long getLong(Object obj, long l);
    public native int arrayBaseOffset(Class class1);
    public native int arrayIndexScale(Class class1);

    static 
    {
        ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset([I);
        ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale([I);
    }
}      

3、挂起與恢複

将一個線程進行挂起是通過park方法實作的，調用 park後，線程将一直阻塞直到逾時或者中斷等條件出現。unpark可以終止一個挂起的線程，使其恢複正常。整個并發架構中對線程的挂起操作被封裝在 LockSupport類中，LockSupport類中有各種版本pack方法，但最終都調用了Unsafe.park()方法。

public class LockSupport {
    public static void unpark(Thread thread) {
        if (thread != null)
            unsafe.unpark(thread);
    }

    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(false, 0L);
        setBlocker(t, null);
    }

    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            unsafe.park(false, nanos);
            setBlocker(t, null);
        }
    }

    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(true, deadline);
        setBlocker(t, null);
    }

    public static void park() {
        unsafe.park(false, 0L);
    }

    public static void parkNanos(long nanos) {
        if (nanos > 0)
            unsafe.park(false, nanos);
    }

    public static void parkUntil(long deadline) {
        unsafe.park(true, deadline);
    }
}      

4、CAS操作

是通過compareAndSwapXXX方法實作的

/**
* 比較obj的offset處記憶體位置中的值和期望的值，如果相同則更新。此更新是不可中斷的。
* 
* @param obj 需要更新的對象
* @param offset obj中整型field的偏移量
* @param expect 希望field中存在的值
* @param update 如果期望值expect與field的目前值相同，設定filed的值為這個新值
* @return 如果field的值被更改傳回true
*/
public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);      

CAS操作有3個操作數，記憶體值M，預期值E，新值U，如果M==E，則将記憶體值修改為B，否則啥都不做。

參考資料：

Unsafe.h

源碼剖析之sun.misc.Unsafe

注：轉自http://blog.csdn.net/aesop_wubo/article/details/7537278

首先介紹一下什麼是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可以參考下面這篇文章：

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html Java 理論與實踐: 正确使用 Volatile 變量

下面來看看java中具體的CAS操作類sun.misc.Unsafe。Unsafe類提供了硬體級别的原子操作，Java無法直接通路到作業系統底層（如系統硬體等)，為此Java使用native方法來擴充Java程式的功能。具體實作使用c++,詳見檔案sun.misc.natUnsafe.cc();sun.misc包的源代碼可以在這裡找到：

http://www.oschina.net/code/explore/gcc-4.5.2/libjava/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 ([email protected])
 * @author Andrew John Hughes ([email protected])
 */
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 href="#arrayIndexScale" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>arrayIndexScale</code></a>,
   * if non-zero.
   * 擷取給定數組中第一個元素的偏移位址。
   * 為了存取數組中的元素，這個偏移位址與<a href="#arrayIndexScale" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>arrayIndexScale
   * </code></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 href="#arrayBaseOffset" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>arrayBaseOffset</code></a>
   * to access elements of the class.
   * 擷取使用者給定數組尋址的換算因子.一個合适的換算因子不能傳回的時候(例如：基本類型),
   * 傳回0.這個傳回值能夠與<a href="#arrayBaseOffset" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><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 href="#park" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>park</code></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 href="#park" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>park</code></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 href="#unpark" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>unpark</code></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 href="#unpark" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>unpark</code></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);
}      

注：轉自http://blog.csdn.net/zgmzyr/article/details/8902683

下面這個例子示範了簡單的修改一個byte[]的資料。

這個例子在eclipse裡不能直接編譯，要到項目的屬性，Java Compiler，Errors/Warnings中Forbidden reference(access rules)中設定為warning。

另外，因為sun.misc.Unsafe包不能直接使用，所有代碼裡用反射的技巧得到了一個Unsafe的執行個體。

import java.lang.reflect.Field;
import java.util.Arrays;
import sun.misc.Unsafe;

public class Test {
    private static int byteArrayBaseOffset;

    public static void main(String[] args) throws SecurityException,
            NoSuchFieldException, IllegalArgumentException,
            IllegalAccessException {
        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        Unsafe UNSAFE = (Unsafe) theUnsafe.get(null);
        System.out.println(UNSAFE);

        byte[] data = new byte[10];
        System.out.println(Arrays.toString(data));
        byteArrayBaseOffset = UNSAFE.arrayBaseOffset(byte[].class);

        System.out.println(byteArrayBaseOffset);
        UNSAFE.putByte(data, byteArrayBaseOffset, (byte) 1);
        UNSAFE.putByte(data, byteArrayBaseOffset + 5, (byte) 5);
        System.out.println(Arrays.toString(data));
    }
}      

運作結果：

[email protected]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
24
[1, 0, 0, 0, 0, 5, 0, 0, 0, 0]      

注：轉自http://blog.csdn.net/hengyunabc/article/details/7657934

以下為Unsafe類涉及到的源碼：

• natUnsafe.cc
• Service.h
• ServiceConfigurationError.h
• Unsafe.h
• Unsafe.java

  

  /** Unsafe.java - Unsafe operations needed for concurrency
     Copyright (C) 2006 Free Software Foundation
  
  This file is part of GNU Classpath.
  
  GNU Classpath is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2, or (at your option)
  any later version.
  
  GNU Classpath is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.
  
  You should have received a copy of the GNU General Public License
  along with GNU Classpath; see the file COPYING.  If not, write to the
  Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  02110-1301 USA.
  
  Linking this library statically or dynamically with other modules is
  making a combined work based on this library.  Thus, the terms and
  conditions of the GNU General Public License cover the whole
  combination.
  
  As a special exception, the copyright holders of this library give you
  permission to link this library with independent modules to produce an
  executable, regardless of the license terms of these independent
  modules, and to copy and distribute the resulting executable under
  terms of your choice, provided that you also meet, for each linked
  independent module, the terms and conditions of the license of that
  module.  An independent module is a module which is not derived from
  or based on this library.  If you modify this library, you may extend
  this exception to your version of the library, but you are not
  obligated to do so.  If you do not wish to do so, delete this
  exception statement from your version. */
  
  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.
   *
   * @author Tom Tromey ([email protected])
   * @author Andrew John Hughes ([email protected])
   */
  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.
     *
     * @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.
     *
     * @param field the field whose offset should be returned.
     * @return the offset of the given 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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the integer field within <code>obj</code>.
     * @param expect the expected value of the field.
     * @param update the new value of the field if it equals <code>expect</code>.
     * @return true if the field was changed.
     */
    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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the long field within <code>obj</code>.
     * @param expect the expected value of the field.
     * @param update the new value of the field if it equals <code>expect</code>.
     * @return true if the field was changed.
     */
    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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the object field within <code>obj</code>.
     * @param expect the expected value of the field.
     * @param update the new value of the field if it equals <code>expect</code>.
     * @return true if the field was changed.
     */
    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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the integer field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the long field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the object field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the integer field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to read.
     * @param offset the offset of the integer field within <code>obj</code>.
     */
    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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the long field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the long field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to read.
     * @param offset the offset of the long field within <code>obj</code>.
     * @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.
     *
     * @param obj the object containing the field to read.
     * @param offset the offset of the long field within <code>obj</code>.
     * @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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the object field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to modify.
     * @param offset the offset of the object field within <code>obj</code>.
     * @param value the new value of the 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.
     *
     * @param obj the object containing the field to read.
     * @param offset the offset of the object field within <code>obj</code>.
     */
    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 that returned by 
     * <a href="#arrayIndexScale" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>arrayIndexScale</code></a>,
     * if non-zero.
     *
     * @param arrayClass the class for which the first element's address should
     *                   be obtained.
     * @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 href="#arrayBaseOffset" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>arrayBaseOffset</code></a>
     * to access elements of the 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 href="#park" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>park</code></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.
     *
     * @param thread the thread to unblock.
     */
    public native void unpark(Thread thread);
  
    /***
     * Blocks the thread until a matching 
     * <a href="#unpark" target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow"  target="_blank" rel="external nofollow" ><code>unpark</code></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).
     *
     * @param isAbsolute true if the timeout is specified in milliseconds from
     *                   the epoch.
     * @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);
  
  }      

  

Unsafe.h

// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-

#ifndef __sun_misc_Unsafe__
#define __sun_misc_Unsafe__

#pragma interface

#include <java/lang/Object.h>
extern "Java"
{
  namespace sun
  {
    namespace misc
    {
        class Unsafe;
    }
  }
}

class sun::misc::Unsafe : public ::java::lang::Object
{

  Unsafe();
public:
  static ::sun::misc::Unsafe * getUnsafe();
  virtual jlong objectFieldOffset(::java::lang::reflect::Field *);
  virtual jboolean compareAndSwapInt(::java::lang::Object *, jlong, jint, jint);
  virtual jboolean compareAndSwapLong(::java::lang::Object *, jlong, jlong, jlong);
  virtual jboolean compareAndSwapObject(::java::lang::Object *, jlong, ::java::lang::Object *, ::java::lang::Object *);
  virtual void putOrderedInt(::java::lang::Object *, jlong, jint);
  virtual void putOrderedLong(::java::lang::Object *, jlong, jlong);
  virtual void putOrderedObject(::java::lang::Object *, jlong, ::java::lang::Object *);
  virtual void putIntVolatile(::java::lang::Object *, jlong, jint);
  virtual jint getIntVolatile(::java::lang::Object *, jlong);
  virtual void putLongVolatile(::java::lang::Object *, jlong, jlong);
  virtual void putLong(::java::lang::Object *, jlong, jlong);
  virtual jlong getLongVolatile(::java::lang::Object *, jlong);
  virtual jlong getLong(::java::lang::Object *, jlong);
  virtual void putObjectVolatile(::java::lang::Object *, jlong, ::java::lang::Object *);
  virtual void putObject(::java::lang::Object *, jlong, ::java::lang::Object *);
  virtual ::java::lang::Object * getObjectVolatile(::java::lang::Object *, jlong);
  virtual jint arrayBaseOffset(::java::lang::Class *);
  virtual jint arrayIndexScale(::java::lang::Class *);
  virtual void unpark(::java::lang::Thread *);
  virtual void park(jboolean, jlong);
private:
  static ::sun::misc::Unsafe * unsafe;
public:
  static ::java::lang::Class class$;
};

#endif // __sun_misc_Unsafe__      

ServiceConfigurationError.h

// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-

#ifndef __sun_misc_ServiceConfigurationError__
#define __sun_misc_ServiceConfigurationError__

#pragma interface

#include <java/lang/Error.h>
extern "Java"
{
  namespace sun
  {
    namespace misc
    {
        class ServiceConfigurationError;
    }
  }
}

class sun::misc::ServiceConfigurationError : public ::java::lang::Error
{

public:
  ServiceConfigurationError();
  ServiceConfigurationError(::java::lang::String *);
  static ::java::lang::Class class$;
};

#endif // __sun_misc_ServiceConfigurationError__      

Service.h

// DO NOT EDIT THIS FILE - it is machine generated -*- c++ -*-

#ifndef __sun_misc_Service__
#define __sun_misc_Service__

#pragma interface

#include <java/lang/Object.h>
extern "Java"
{
  namespace sun
  {
    namespace misc
    {
        class Service;
    }
  }
}

class sun::misc::Service : public ::java::lang::Object
{

public:
  Service();
  static ::java::util::Iterator * providers(::java::lang::Class *, ::java::lang::ClassLoader *);
  static ::java::lang::Class class$;
};

#endif // __sun_misc_Service__      

natUnsafe.cc

// natUnsafe.cc - Implementation of sun.misc.Unsafe native methods.

/** Copyright (C) 2006, 2007
   Free Software Foundation

   This file is part of libgcj.

This software is copyrighted work licensed under the terms of the
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
details.  */

#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);
}