JAVA并发编程学习笔记之Unsafe类

java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作，主要提供了以下功能：

1、通过Unsafe类可以分配内存，可以释放内存；

类中提供的3个本地方法allocateMemory、reallocateMemory、freeMemory分别用于分配内存，扩充内存和释放内存，与C语言中的3个方法对应。

2、可以定位对象某字段的内存位置，也可以修改对象的字段值，即使它是私有的；

[java]  view plain  copy

 print ?

1. public native long allocateMemory(long l);  
2. public native long reallocateMemory(long l, long l1);  
3. public native void freeMemory(long l);  

字段的定位：

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配合使用，可以定位数组中每个元素在内存中的位置。

[java]  view plain  copy

 print ?

1. public final class Unsafe {  
2.     public static final int ARRAY_INT_BASE_OFFSET;  
3.     public static final int ARRAY_INT_INDEX_SCALE;  
4.   
5.     public native long staticFieldOffset(Field field);  
6.     public native int getIntVolatile(Object obj, long l);  
7.     public native long getLong(Object obj, long l);  
8.     public native int arrayBaseOffset(Class class1);  
9.     public native int arrayIndexScale(Class class1);  
10.   
11.     static   
12.     {  
13.         ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset([I);  
14.         ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale([I);  
15.     }  
16. }  

3、挂起与恢复

将一个线程进行挂起是通过park方法实现的，调用 park后，线程将一直阻塞直到超时或者中断等条件出现。unpark可以终止一个挂起的线程，使其恢复正常。整个并发框架中对线程的挂起操作被封装在 LockSupport类中，LockSupport类中有各种版本pack方法，但最终都调用了Unsafe.park()方法。

[java]  view plain  copy

 print ?

1. public class LockSupport {  
2.     public static void unpark(Thread thread) {  
3.         if (thread != null)  
4.             unsafe.unpark(thread);  
5.     }  
6.   
7.     public static void park(Object blocker) {  
8.         Thread t = Thread.currentThread();  
9.         setBlocker(t, blocker);  
10.         unsafe.park(false, 0L);  
11.         setBlocker(t, null);  
12.     }  
13.   
14.     public static void parkNanos(Object blocker, long nanos) {  
15.         if (nanos > 0) {  
16.             Thread t = Thread.currentThread();  
17.             setBlocker(t, blocker);  
18.             unsafe.park(false, nanos);  
19.             setBlocker(t, null);  
20.         }  
21.     }  
22.   
23.     public static void parkUntil(Object blocker, long deadline) {  
24.         Thread t = Thread.currentThread();  
25.         setBlocker(t, blocker);  
26.         unsafe.park(true, deadline);  
27.         setBlocker(t, null);  
28.     }  
29.   
30.     public static void park() {  
31.         unsafe.park(false, 0L);  
32.     }  
33.   
34.     public static void parkNanos(long nanos) {  
35.         if (nanos > 0)  
36.             unsafe.park(false, nanos);  
37.     }  
38.   
39.     public static void parkUntil(long deadline) {  
40.         unsafe.park(true, deadline);  
41.     }  
42. }  

4、CAS操作

是通过compareAndSwapXXX方法实现的

[java]  view plain  copy

 print ?

1. /** 
2. * 比较obj的offset处内存位置中的值和期望的值，如果相同则更新。此更新是不可中断的。 
3. *  
4. * @param obj 需要更新的对象 
5. * @param offset obj中整型field的偏移量 
6. * @param expect 希望field中存在的值 
7. * @param update 如果期望值expect与field的当前值相同，设置filed的值为这个新值 
8. * @return 如果field的值被更改返回true 
9. */  
10. public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);  

CAS操作有3个操作数，内存值M，预期值E，新值U，如果M==E，则将内存值修改为B，否则啥都不做。

实例化sun.misc.Unsafe

    如果你尝试创建Unsafe类的实例，基于以下两种原因是不被允许的。

    1）、Unsafe类的构造函数是私有的；

    2）、虽然它有静态的getUnsafe()方法，但是如果你尝试调用Unsafe.getUnsafe()，会得到一个SecutiryException。这个类只有被JDK信任的类实例化。

    但是这总会是有变通的解决办法的，一个简单的方式就是使用反射进行实例化：

[java]  view plain  copy

 

1. Field f = Unsafe.class.getDeclaredField("theUnsafe"); //Internal reference  
2. f.setAccessible(true);  
3. Unsafe unsafe = (Unsafe) f.get(null);  

    注：IDE如Eclipse对会这样的使用报错，不过不用担心，直接运行代码就行，可以正常运行的。

    （译者注：还有一种解决方案，就是将Eclipse中这种限制获取由错误，修改为警告，具体操作为将Windows->Preference...->Java->Compiler->Errors/Warnings中的"Deprecated and restricted API"，级别由Error修改为Warning就可以了）

    现在进入主题，使用这个对象我们可以做如下“有趣的”事情。

    使用sun.misc.Unsafe

    1）、突破限制创建实例

    通过allocateInstance()方法，你可以创建一个类的实例，但是却不需要调用它的构造函数、初使化代码、各种JVM安全检查以及其它的一些底层的东西。即使构造函数是私有，我们也可以通过这个方法创建它的实例。

    （这个对单例模式情有独钟的程序员来说将会是一个噩梦，它们没有办法阻止这种方式调用）

    看下面一个实例（注：为了配合这个主题，译者将原实例中的public构造函数修改为了私有的）：

 

[java]  view plain  copy

 

1. public class UnsafeDemo {  
2.     public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException, InstantiationException {  
3.         Field f = Unsafe.class.getDeclaredField("theUnsafe"); // Internal reference  
4.         f.setAccessible(true);  
5.         Unsafe unsafe = (Unsafe) f.get(null);  
6.   
7.         // This creates an instance of player class without any initialization  
8.         Player p = (Player) unsafe.allocateInstance(Player.class);  
9.         System.out.println(p.getAge()); // Print 0  
10.   
11.         p.setAge(45); // Let's now set age 45 to un-initialized object  
12.         System.out.println(p.getAge()); // Print 45  
13.     }  
14. }  
15.   
16. class Player {  
17.     private int age = 12;  
18.   
19.     private Player() {  
20.         this.age = 50;  
21.     }  
22.   
23.     public int getAge() {  
24.         return this.age;  
25.     }  
26.   
27.     public void setAge(int age) {  
28.         this.age = age;  
29.     }  
30. }  

    2）、使用直接获取内存的方式实现浅克隆

    如何实现浅克隆？在clone(){...}方法中调用super.clone()，对吗？这里存在的问题是首先你必须继续Cloneable接口，并且在所有你需要做浅克隆的对象中实现clone()方法，对于一个懒懒的程序员来说，这个工作量太大了。

    我不推荐上面的做法而是直接使用Unsafe，我们可以仅使用几行代码就实现浅克隆，并且它可以像某些工具类一样用于任意类的克隆。

    这个戏法就是把一个对象的字节码拷贝到内存的另外一个地方，然后再将这个对象转换为被克隆的对象类型。