关于Java Unsafe

最近看《Java并发编程的艺术》，其中多次提到Unsafe。很有意思的一个api，从名字上看很奇怪，并且不是公开的api，只有在JDK内部才能使用。查阅了一些资料：

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

http://aswang.iteye.com/blog/1741871

http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/
http://www.docjar.com/html/api/sun/misc/Unsafe.java.html
当然，搞Android的，少不了Android源代码：

libcore/libart/src/main/java/sun/misc/Unsafe.java

就几个我感兴趣的点研究一下：

（1）为什么叫unsafe？
http://mishadoff.com/blog/java-magic-part-4-sun-dot-misc-dot-unsafe/：

Java is a safe programming language and prevents programmer from doing a lot of stupid mistakes, most of which based on memory management. But, there is a way to do suchmistakes intentionally, using

Unsafe

class.

Android源代码：

/**

 * The package name notwithstanding, this class is the quasi-standard

 * way for Java code to gain access to and use functionality which,

 * when unsupervised, would allow one to break the pointer/type safety

 * of Java.

 */

所谓Unsafe，即提供了一些API，可以绕过Java的安全机制（基于Java类型、引用、内存管理机制，对于内存访问的严格控制），进行一些更直接、更底层的操作，显然，在经典的Java编程风格中，这些操作是不安全的。这相当于Java的后门，所以只有JDK内部才能使用。

（2）原子api

Unsafe提供的一系列cas原子api，是JDK中原子操作类的实现基础。

http://www.docjar.com/html/api/sun/misc/Unsafe.java.html 注释中对此描述较清楚：

858       /**
859        * Atomically update Java variable to <tt>x</tt> if it is currently
860        * holding <tt>expected</tt>.
861        * @return <tt>true</tt> if successful
862        */
863       public final native boolean compareAndSwapObject(Object o, long offset,
864                                                        Object expected,
865                                                        Object x);
866
867       /**
868        * Atomically update Java variable to <tt>x</tt> if it is currently
869        * holding <tt>expected</tt>.
870        * @return <tt>true</tt> if successful
871        */
872       public final native boolean compareAndSwapInt(Object o, long offset,
873                                                     int expected,
874                                                     int x);
875
876       /**
877        * Atomically update Java variable to <tt>x</tt> if it is currently
878        * holding <tt>expected</tt>.
879        * @return <tt>true</tt> if successful
880        */
881       public final native boolean compareAndSwapLong(Object o, long offset,
882                                                      long expected,
883                                                      long x);

（3）在安卓上如何实现的原子api？

以Unsafe.compareAndSwapInt()为例，追到native，一探究竟。

libcore/libart/src/main/java/sun/misc/Unsafe.java:

/**
* Performs a compare-and-set operation on an <code>int</code>
* field within the given object.
*
* @param obj non-null; object containing the field
* @param offset offset to the field within <code>obj</code>
* @param expectedValue expected value of the field
* @param newValue new value to store in the field if the contents are
* as expected
* @return <code>true</code> if the new value was in fact stored, and
* <code>false</code> if not
*/
public native boolean compareAndSwapInt(Object obj, long offset,
int expectedValue, int newValue);

显然，这是一个native method。在Android codebase中搜索native定义，发现了：

art/runtime/native/sun_misc_Unsafe.cc:

static jboolean Unsafe_compareAndSwapInt(JNIEnv* env, jobject, jobject javaObj, jlong offset,
jint expectedValue, jint newValue) {
ScopedFastNativeObjectAccess soa(env);
mirror::Object* obj = soa.Decode<mirror::Object*>(javaObj);
// JNI must use non transactional mode.
bool success = obj->CasFieldStrongSequentiallyConsistent32<false>(MemberOffset(offset),
expectedValue, newValue);
return success ? JNI_TRUE : JNI_FALSE;
}

调用了mirror::Object的CasFieldStrongSequentiallyConsistent32()，寻找定义：

art/runtime/mirror/object-inl.h：

template<bool kTransactionActive, bool kCheckTransaction, VerifyObjectFlags kVerifyFlags>
inline bool Object::CasFieldStrongSequentiallyConsistent32(MemberOffset field_offset,
int32_t old_value, int32_t new_value) {
if (kCheckTransaction) {
DCHECK_EQ(kTransactionActive, Runtime::Current()->IsActiveTransaction());
}
if (kTransactionActive) {
Runtime::Current()->RecordWriteField32(this, field_offset, old_value, true);
}
if (kVerifyFlags & kVerifyThis) {
VerifyObject(this);
}
uint8_t* raw_addr = reinterpret_cast<uint8_t*>(this) + field_offset.Int32Value();
AtomicInteger* atomic_addr = reinterpret_cast<AtomicInteger*>(raw_addr);

return atomic_addr->CompareExchangeStrongSequentiallyConsistent(old_value, new_value);
}

关键调用AtomicInteger的CompareExchangeStrongSequentiallyConsistent():

art/runtime/atomic.h:

// Atomically replace the value with desired value if it matches the expected value.
// Participates in total ordering of atomic operations.
bool CompareExchangeStrongSequentiallyConsistent(T expected_value, T desired_value) {
return this->compare_exchange_strong(expected_value, desired_value, std::memory_order_seq_cst);
}

这段代码出现在类
template<typename T>

class PACKED(sizeof(T)) Atomic : public std::atomic<T>

可见，实际上使用的是std::atomic->compare_exchange_strong()

std::atomic有两个api：

compare_exchange_strong()

compare_exchange_weak()

api参考文档：

http://www.cplusplus.com/reference/atomic/atomic/compare_exchange_weak/

http://www.cplusplus.com/reference/atomic/atomic/compare_exchange_strong/

两个API基本功能是相同的

Compares the contents of the contained value with expected:

- if true, it replaces the contained value with val (like
store).

- if false, it replaces expected with the contained value .

区别在于weak可能在满足true的情况下仍然返回false，所以只能在循环里使用，否则可以使用strong。之所以有weak版本是因为可以在某些平台上提升性能。