源碼剖析sun.misc.Unsafe && Compare And Swap(CAS)操作

轉載自：http://blog.csdn.net/liupeng900605/article/details/7825286；特別感謝！

首先介紹一下什麼是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"><code>arrayIndexScale</code></a>,
   * if non-zero.
   * 獲取給定數組中第一個元素的偏移地址。
   * 爲了存取數組中的元素，這個偏移地址與<a href="#arrayIndexScale"><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"><code>arrayBaseOffset</code></a>
   * to access elements of the class.
   * 獲取用戶給定數組尋址的換算因子.一個合適的換算因子不能返回的時候(例如：基本類型),
   * 返回0.這個返回值能夠與<a href="#arrayBaseOffset"><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"><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"><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"><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"><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);

}

//下面是sun.misc.natUnsafe.cc源碼

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

}

這是一個非常強大的類，提供了硬件級別的原子操作。

以下是我通過閱讀其他一些已經開源的JDK源碼，通過它們對該類的調，總結出來的API，如有錯誤請指正。

本文版權歸“亂七八糟的代碼（blog.csdn.net/alifel）”所有，如需轉載請註明出處，否則必追究其版權問題！

[java] view
plaincopy

/** 

*比較並更新對象的某一個整數類型的域 

*@param obj 被操作的對象 

*@param fieldoffset 被操作的域在對象中的偏移量 

*@param expect 域的期望值 

*@param update 域的更新值 

*/  

boolean compareAndSwapInt(Object obj,long fieldoffset, int expect, int update);  

/** 

*比較並更新對象的某一個對象類型的域 

*@param obj 被操作的對象 

*@param fieldoffset 被操作的域在對象中的偏移量 

*@param expect 域的期望值 

*@param update 域的更新值 

*/  

boolean compareAndSwapObject(Object obj,long Fieldoffset, Object expect, Object update);  

/** 

*獲得對象某個域的偏移量 

*@param field 要獲得偏移量的域 

*/  

long objectFieldOffset (Field field);  

/** 

*使當前線程在指定的等待時間之前一直等待 

*@param flag 等待時間類型 true代表絕對時間(用相對於曆元 

*(Epoch) 的毫秒數值表示),false代表相對時間 

*@param time 等待的時間，單位毫秒 

*/  

void park(boolean flag, long time);  

/** 

*取消指定線程的等待 

*@param thread 被取消等待的線程 

*/  

void unpark(Thread  thread)  

/** 

*通過偏移量，獲取某個對象Object類型的域 

*@param obj 被操作的對象 

*@param fieldoffset 偏移量 

*/  

Object getObject(Object obj,long fieldoffset);  

/** 

*通過偏移量，獲取某個對象整數類型的域 

*@param obj 被操作的對象 

*@param fieldoffset 偏移量 

*/  

int getInt(Object obj,long fieldoffset);

源碼剖析sun.misc.Unsafe && Compare And Swap(CAS)操作

二叉樹系列之一（基本概念）

Web容器初始化時獲取bean的幾種方法

strtusAction中的獲取request

二叉樹系列之二（遍歷與查找）

Java中String的探究

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結