现在的位置: 首页 > 综合 > 正文

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

2013年10月28日 ⁄ 综合 ⁄ 共 3308字 ⁄ 字号 评论关闭

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

1、通过Unsafe类可以分配内存,可以释放内存;

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

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

  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配合使用,可以定位数组中每个元素在内存中的位置。
  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()方法。
  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方法实现的
  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,否则啥都不做。
参考资料:

抱歉!评论已关闭.