Java併發指南16：JUC中常用的Unsafe和Locksupport
最近在看Java併發包的原始碼，發現了神奇的Unsafe類，仔細研究了一下，在這裡跟大家分享一下。
Unsafe類是在sun.misc包下，不屬於Java標準。但是很多Java的基礎類庫，包括一些被廣泛使用的高效能開發庫都是基於Unsafe類開發的，比如Netty、Cassandra、Hadoop、Kafka等。Unsafe類在提升Java執行效率，增強Java語言底層操作能力方面起了很大的作用。
Unsafe類使Java擁有了像C語言的指標一樣操作記憶體空間的能力，同時也帶來了指標的問題。過度的使用Unsafe類會使得出錯的機率變大，因此Java官方並不建議使用的，官方文件也幾乎沒有。Oracle正在計劃從Java 9中去掉Unsafe類，如果真是如此影響就太大了。
通常我們最好也不要使用Unsafe類，除非有明確的目的，並且也要對它有深入的瞭解才行。要想使用Unsafe類需要用一些比較tricky的辦法。Unsafe類使用了單例模式，需要通過一個靜態方法getUnsafe()來獲取。但Unsafe類做了限制，如果是普通的呼叫的話，它會丟擲一個SecurityException異常；只有由主類載入器載入的類才能呼叫這個方法。其原始碼如下：
1 public static Unsafe getUnsafe() { 2 Class var0 = Reflection.getCallerClass(); 3 if(!VM.isSystemDomainLoader(var0.getClassLoader())) {4 throw new SecurityException("Unsafe"); 5 } else { 6 return theUnsafe; 7 } 8 }
網上也有一些辦法來用主類載入器載入使用者程式碼，比如設定bootclasspath引數。但更簡單方法是利用Java反射，方法如下：
1 Field f = Unsafe.class.getDeclaredField("theUnsafe"); 2 f.setAccessible(true); 3 Unsafe unsafe = (Unsafe) f.get(null);
獲取到Unsafe例項之後，我們就可以為所欲為了。Unsafe類提供了以下這些功能：
一、記憶體管理。包括分配記憶體、釋放記憶體等。
該部分包括了allocateMemory（分配記憶體）、reallocateMemory（重新分配記憶體）、copyMemory（拷貝記憶體）、freeMemory（釋放記憶體 ）、getAddress（獲取記憶體地址）、addressSize、pageSize、getInt（獲取記憶體地址指向的整數）、getIntVolatile（獲取記憶體地址指向的整數，並支援volatile語義）、putInt（將整數寫入指定記憶體地址）、putIntVolatile（將整數寫入指定記憶體地址，並支援volatile語義）、putOrderedInt（將整數寫入指定記憶體地址、有序或者有延遲的方法）等方法。getXXX和putXXX包含了各種基本型別的操作。
利用copyMemory方法，我們可以實現一個通用的物件拷貝方法，無需再對每一個物件都實現clone方法，當然這通用的方法只能做到物件淺拷貝。
二、非常規的物件例項化。
allocateInstance()方法提供了另一種建立例項的途徑。通常我們可以用new或者反射來例項化物件，使用allocateInstance()方法可以直接生成物件例項，且無需呼叫構造方法和其它初始化方法。
這在物件反序列化的時候會很有用，能夠重建和設定final欄位，而不需要呼叫構造方法。
三、操作類、物件、變數。
這部分包括了staticFieldOffset（靜態域偏移）、defineClass（定義類）、defineAnonymousClass（定義匿名類）、ensureClassInitialized（確保類初始化）、objectFieldOffset（物件域偏移）等方法。
通過這些方法我們可以獲取物件的指標，通過對指標進行偏移，我們不僅可以直接修改指標指向的資料（即使它們是私有的），甚至可以找到JVM已經認定為垃圾、可以進行回收的物件。
四、陣列操作。
這部分包括了arrayBaseOffset（獲取陣列第一個元素的偏移地址）、arrayIndexScale（獲取陣列中元素的增量地址）等方法。arrayBaseOffset與arrayIndexScale配合起來使用，就可以定位陣列中每個元素在記憶體中的位置。
由於Java的陣列最大值為Integer.MAX_VALUE，使用Unsafe類的記憶體分配方法可以實現超大陣列。實際上這樣的資料就可以認為是C陣列，因此需要注意在合適的時間釋放記憶體。
五、多執行緒同步。包括鎖機制、CAS操作等。
這部分包括了monitorEnter、tryMonitorEnter、monitorExit、compareAndSwapInt、compareAndSwap等方法。
其中monitorEnter、tryMonitorEnter、monitorExit已經被標記為deprecated，不建議使用。
Unsafe類的CAS操作可能是用的最多的，它為Java的鎖機制提供了一種新的解決辦法，比如AtomicInteger等類都是通過該方法來實現的。compareAndSwap方法是原子的，可以避免繁重的鎖機制，提高程式碼效率。這是一種樂觀鎖，通常認為在大部分情況下不出現競態條件，如果操作失敗，會不斷重試直到成功。
六、掛起與恢復。
這部分包括了park、unpark等方法。
將一個執行緒進行掛起是通過park方法實現的，呼叫 park後，執行緒將一直阻塞直到超時或者中斷等條件出現。unpark可以終止一個掛起的執行緒，使其恢復正常。整個併發框架中對執行緒的掛起操作被封裝在 LockSupport類中，LockSupport類中有各種版本pack方法，但最終都呼叫了Unsafe.park()方法。
七、記憶體屏障。
這部分包括了loadFence、storeFence、fullFence等方法。這是在Java 8新引入的，用於定義記憶體屏障，避免程式碼重排序。
loadFence() 表示該方法之前的所有load操作在記憶體屏障之前完成。同理storeFence()表示該方法之前的所有store操作在記憶體屏障之前完成。fullFence()表示該方法之前的所有load、store操作在記憶體屏障之前完成。
Unsafe類是啥？
Java最初被設計為一種安全的受控環境。儘管如此，Java HotSpot還是包含了一個“後門”，提供了一些可以直接操控記憶體和執行緒的低層次操作。這個後門類——sun.misc.Unsafe——被JDK廣泛用於自己的包中，如java.nio和java.util.concurrent。但是絲毫不建議在生產環境中使用這個後門。因為這個API十分不安全、不輕便、而且不穩定。這個不安全的類提供了一個觀察HotSpot JVM內部結構並且可以對其進行修改。有時它可以被用來在不適用C++除錯的情況下學習虛擬機器內部結構，有時也可以被拿來做效能監控和開發工具。
為什麼叫Unsafe？
Java官方不推薦使用Unsafe類，因為官方認為，這個類別人很難正確使用，非正確使用會給JVM帶來致命錯誤。而且未來Java可能封閉丟棄這個類。
如何使用Unsafe？
1. 獲取Unsafe例項：
通讀Unsafe原始碼，Unsafe提供了一個私有的靜態例項，並且通過檢查classloader是否為null來避免java程式直接使用unsafe：
//Unsafe原始碼
private static final Unsafe theUnsafe;
@CallerSensitive
public static Unsafe getUnsafe() {
Class var0 = Reflection.getCallerClass();
if(var0.getClassLoader() != null) {
throw new SecurityException("Unsafe");
} else {
return theUnsafe;
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
我們可以通過如下程式碼反射獲取Unsafe靜態類：
/**
* 獲取Unsafe
*/
Field f = null;
Unsafe unsafe = null;
try {
f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
unsafe = (Unsafe) f.get(null);
} catch (NoSuchFieldException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
2. 通過Unsafe分配使用堆外記憶體：
C++中有malloc，realloc和free方法來操作記憶體。在Unsafe類中對應為：
//分配var1位元組大小的記憶體，返回起始地址偏移量
public native long allocateMemory(long var1);
//重新給var1起始地址的記憶體分配長度為var3位元組大小的記憶體，返回新的記憶體起始地址偏移量
public native long reallocateMemory(long var1, long var3);
//釋放起始地址為var1的記憶體
public native void freeMemory(long var1);- 1
- 2
- 3
- 4
- 5
- 6
分配記憶體方法還有重分配記憶體方法都是分配的堆外記憶體，返回的是一個long型別的地址偏移量。這個偏移量在你的Java程式中每塊記憶體都是唯一的。
舉例：
/**
* 在堆外分配一個byte
*/
long allocatedAddress = unsafe.allocateMemory(1L);
unsafe.putByte(allocatedAddress, (byte) 100);
byte shortValue = unsafe.getByte(allocatedAddress);
System.out.println(new StringBuilder().append("Address:").append(allocatedAddress).append(" Value:").append(shortValue));
/**
* 重新分配一個long
*/
allocatedAddress = unsafe.reallocateMemory(allocatedAddress, 8L);
unsafe.putLong(allocatedAddress, 1024L);
long longValue = unsafe.getLong(allocatedAddress);
System.out.println(new StringBuilder().append("Address:").append(allocatedAddress).append(" Value:").append(longValue));
/**
* Free掉,這個資料可能髒掉
*/
unsafe.freeMemory(allocatedAddress);
longValue = unsafe.getLong(allocatedAddress);
System.out.println(new StringBuilder().append("Address:").append(allocatedAddress).append(" Value:").append(longValue));- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
輸出：
Address:46490464 Value:100
Address:46490480 Value:1024
Address:46490480 Value:22- 1
- 2
- 3
3. 操作類物件
我們可以通過Unsafe類來操作修改某一field。原理是首先獲取物件的基址（物件在記憶體的偏移量起始地址）。之後獲取某個filed在這個物件對應的類中的偏移地址，兩者相加修改。
/**
* 獲取類的某個物件的某個field偏移地址
*/
try {
f = SampleClass.class.getDeclaredField("i");
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
long iFiledAddressShift = unsafe.objectFieldOffset(f);
SampleClass sampleClass = new SampleClass();
//獲取物件的偏移地址，需要將目標物件設為輔助陣列的第一個元素（也是唯一的元素）。由於這是一個複雜型別元素（不是基本資料型別），它的地址儲存在陣列的第一個元素。然後，獲取輔助陣列的基本偏移量。陣列的基本偏移量是指陣列物件的起始地址與陣列第一個元素之間的偏移量。
Object helperArray[] = new Object[1];
helperArray[0] = sampleClass;
long baseOffset = unsafe.arrayBaseOffset(Object[].class);
long addressOfSampleClass = unsafe.getLong(helperArray, baseOffset);
int i = unsafe.getInt(addressOfSampleClass + iFiledAddressShift);
System.out.println(new StringBuilder().append(" Field I Address:").append(addressOfSampleClass).append("+").append(iFiledAddressShift).append(" Value:").append(i));- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
輸出：
Field I Address:3610777760+24 Value:5- 1
4. 執行緒掛起和恢復
將一個執行緒進行掛起是通過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);
}
} - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
5. CAS操作
/**
* 比較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); - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
6. Clone
如何實現淺克隆？在clone(){…}方法中呼叫super.clone()，對嗎？這裡存在的問題是首先你必須繼續Cloneable介面，並且在所有你需要做淺克隆的物件中實現clone()方法，對於一個懶懶的程式設計師來說，這個工作量太大了。
我不推薦上面的做法而是直接使用Unsafe，我們可以僅使用幾行程式碼就實現淺克隆，並且它可以像某些工具類一樣用於任意類的克隆。
首先，我們需要一個計算Object大小的工具類：
class ObjectInfo {
/**
* Field name
*/
public final String name;
/**
* Field type name
*/
public final String type;
/**
* Field data formatted as string
*/
public final String contents;
/**
* Field offset from the start of parent object
*/
public final int offset;
/**
* Memory occupied by this field
*/
public final int length;
/**
* Offset of the first cell in the array
*/
public final int arrayBase;
/**
* Size of a cell in the array
*/
public final int arrayElementSize;
/**
* Memory occupied by underlying array (shallow), if this is array type
*/
public final int arraySize;
/**
* This object fields
*/
public final List<ObjectInfo> children;
public ObjectInfo(String name, String type, String contents, int offset, int length, int arraySize,
int arrayBase, int arrayElementSize) {
this.name = name;
this.type = type;
this.contents = contents;
this.offset = offset;
this.length = length;
this.arraySize = arraySize;
this.arrayBase = arrayBase;
this.arrayElementSize = arrayElementSize;
children = new ArrayList<ObjectInfo>(1);
}
public void addChild(final ObjectInfo info) {
if (info != null)
children.add(info);
}
/**
* Get the full amount of memory occupied by a given object. This value may be slightly less than
* an actual value because we don't worry about memory alignment - possible padding after the last object field.
* <p/>
* The result is equal to the last field offset + last field length + all array sizes + all child objects deep sizes
*
* @return Deep object size
*/
public long getDeepSize() {
//return length + arraySize + getUnderlyingSize( arraySize != 0 );
return addPaddingSize(arraySize + getUnderlyingSize(arraySize != 0));
}
long size = 0;
private long getUnderlyingSize(final boolean isArray) {
//long size = 0;
for (final ObjectInfo child : children)
size += child.arraySize + child.getUnderlyingSize(child.arraySize != 0);
if (!isArray && !children.isEmpty()) {
int tempSize = children.get(children.size() - 1).offset + children.get(children.size() - 1).length;
size += addPaddingSize(tempSize);
}
return size;
}
private static final class OffsetComparator implements Comparator<ObjectInfo> {
@Override
public int compare(final ObjectInfo o1, final ObjectInfo o2) {
return o1.offset - o2.offset; //safe because offsets are small non-negative numbers
}
}
//sort all children by their offset
public void sort() {
Collections.sort(children, new OffsetComparator());
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder();
toStringHelper(sb, 0);
return sb.toString();
}
private void toStringHelper(final StringBuilder sb, final int depth) {
depth(sb, depth).append("name=").append(name).append(", type=").append(type)
.append(", contents=").append(contents).append(", offset=").append(offset)
.append(", length=").append(length);
if (arraySize > 0) {
sb.append(", arrayBase=").append(arrayBase);
sb.append(", arrayElemSize=").append(arrayElementSize);
sb.append(", arraySize=").append(arraySize);
}
for (final ObjectInfo child : children) {
sb.append('\n');
child.toStringHelper(sb, depth + 1);
}
}
private StringBuilder depth(final StringBuilder sb, final int depth) {
for (int i = 0; i < depth; ++i)
sb.append("\t");
return sb;
}
private long addPaddingSize(long size) {
if (size % 8 != 0) {
return (size / 8 + 1) * 8;
}
return size;
}
}
class ClassIntrospector {
private static final Unsafe unsafe;
/**
* Size of any Object reference
*/
private static final int objectRefSize;
static {
try {
Field field = Unsafe.class.getDeclaredField("theUnsafe");
field.setAccessible(true);
unsafe = (Unsafe) field.get(null);
objectRefSize = unsafe.arrayIndexScale(Object[].class);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Sizes of all primitive values
*/
private static final Map<Class, Integer> primitiveSizes;
static {
primitiveSizes = new HashMap<Class, Integer>(10);
primitiveSizes.put(byte.class, 1);
primitiveSizes.put(char.class, 2);
primitiveSizes.put(int.class, 4);
primitiveSizes.put(long.class, 8);
primitiveSizes.put(float.class, 4);
primitiveSizes.put(double.class, 8);
primitiveSizes.put(boolean.class, 1);
}
/**
* Get object information for any Java object. Do not pass primitives to
* this method because they will boxed and the information you will get will
* be related to a boxed version of your value.
*
* @param obj Object to introspect
* @return Object info
* @throws IllegalAccessException
*/
public ObjectInfo introspect(final Object obj)
throws IllegalAccessException {
try {
return introspect(obj, null);
} finally { // clean visited cache before returning in order to make
// this object reusable
m_visited.clear();
}
}
// we need to keep track of already visited objects in order to support
// cycles in the object graphs
private IdentityHashMap<Object, Boolean> m_visited = new IdentityHashMap<Object, Boolean>(
100);
private ObjectInfo introspect(final Object obj, final Field fld)
throws IllegalAccessException {
// use Field type only if the field contains null. In this case we will
// at least know what's expected to be
// stored in this field. Otherwise, if a field has interface type, we
// won't see what's really stored in it.
// Besides, we should be careful about primitives, because they are
// passed as boxed values in this method
// (first arg is object) - for them we should still rely on the field
// type.
boolean isPrimitive = fld != null && fld.getType().isPrimitive();
boolean isRecursive = false; // will be set to true if we have already
// seen this object
if (!isPrimitive) {
if (m_visited.containsKey(obj))
isRecursive = true;
m_visited.put(obj, true);
}
final Class type = (fld == null || (obj != null && !isPrimitive)) ? obj
.getClass() : fld.getType();
int arraySize = 0;
int baseOffset = 0;
int indexScale = 0;
if (type.isArray() && obj != null) {
baseOffset = unsafe.arrayBaseOffset(type);
indexScale = unsafe.arrayIndexScale(type);
arraySize = baseOffset + indexScale * Array.getLength(obj);
}
final ObjectInfo root;
if (fld == null) {
root = new ObjectInfo("", type.getCanonicalName(), getContents(obj,
type), 0, getShallowSize(type), arraySize, baseOffset,
indexScale);
} else {
final int offset = (int) unsafe.objectFieldOffset(fld);
root = new ObjectInfo(fld.getName(), type.getCanonicalName(),
getContents(obj, type), offset, getShallowSize(type),
arraySize, baseOffset, indexScale);
}
if (!isRecursive && obj != null) {
if (isObjectArray(type)) {
// introspect object arrays
final Object[] ar = (Object[]) obj;
for (final Object item : ar)
if (item != null)
root.addChild(introspect(item, null));
} else {
for (final Field field : getAllFields(type)) {
if ((field.getModifiers() & Modifier.STATIC) != 0) {
continue;
}
field.setAccessible(true);
root.addChild(introspect(field.get(obj), field));
}
}
}
root.sort(); // sort by offset
return root;
}
// get all fields for this class, including all superclasses fields
private static List<Field> getAllFields(final Class type) {
if (type.isPrimitive())
return Collections.emptyList();
Class cur = type;
final List<Field> res = new ArrayList<Field>(10);
while (true) {
Collections.addAll(res, cur.getDeclaredFields());
if (cur == Object.class)
break;
cur = cur.getSuperclass();
}
return res;
}
// check if it is an array of objects. I suspect there must be a more
// API-friendly way to make this check.
private static boolean isObjectArray(final Class type) {
if (!type.isArray())
return false;
if (type == byte[].class || type == boolean[].class
|| type == char[].class || type == short[].class
|| type == int[].class || type == long[].class
|| type == float[].class || type == double[].class)
return false;
return true;
}
// advanced toString logic
private static String getContents(final Object val, final Class type) {
if (val == null)
return "null";
if (type.isArray()) {
if (type == byte[].class)
return Arrays.toString((byte[]) val);
else if (type == boolean[].class)
return Arrays.toString((boolean[]) val);
else if (type == char[].class)
return Arrays.toString((char[]) val);
else if (type == short[].class)
return Arrays.toString((short[]) val);
else if (type == int[].class)
return Arrays.toString((int[]) val);
else if (type == long[].class)
return Arrays.toString((long[]) val);
else if (type == float[].class)
return Arrays.toString((float[]) val);
else if (type == double[].class)
return Arrays.toString((double[]) val);
else
return Arrays.toString((Object[]) val);
}
return val.toString();
}
// obtain a shallow size of a field of given class (primitive or object
// reference size)
private static int getShallowSize(final Class type) {
if (type.isPrimitive()) {
final Integer res = primitiveSizes.get(type);
return res != null ? res : 0;
} else
return objectRefSize;
}
}- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
- 140
- 141
- 142
- 143
- 144
- 145
- 146
- 147
- 148
- 149
- 150
- 151
- 152
- 153
- 154
- 155
- 156
- 157
- 158
- 159
- 160
- 161
- 162
- 163
- 164
- 165
- 166
- 167
- 168
- 169
- 170
- 171
- 172
- 173
- 174
- 175
- 176
- 177
- 178
- 179
- 180
- 181
- 182
- 183
- 184
- 185
- 186
- 187
- 188
- 189
- 190
- 191
- 192
- 193