[关闭]
@kiraSally 2018-03-12T10:56:13.000000Z 字数 7691 阅读 2060

并发番@Unsafe一文通（1.8版）

JAVA 并发 源码 1.8版

在此输入正文

1.Unsafe综述

  • 作用： Unsafe是个后门类，封装了一些类似指针的操作，提供了一些可以直接操控内存和线程的底层操作
  • 使用： Unsafe被JDK广泛用于nio包和并发包中，但是不建议在生产环境使用，风险太大
  • 不安全： 不安全指的是指针的操作不安全(Java因此才把指针去掉)，若指针指错位置或计算指针偏移量出错，结果不可想象，比如说覆盖了别人的内存，那可能就GG思密达了...
  • 补充1： 有机会开JVM番的话，笔者会从JVM源码角度重新解析Unsafe一些重要方法的实现
  • 补充2： 此番为 并发番@AQS框架一文通(赶制中)的子番

2.Unsafe的数据结构

2.1 类定义

  1. public final class Unsafe

2.2 构造器

  1. //私有构造器 --单例模式
  2. private Unsafe() {}

2.3 重要变量

  1. private static final Unsafe theUnsafe;
  2. public static final int INVALID_FIELD_OFFSET = -1;
  3. public static final int ARRAY_BOOLEAN_BASE_OFFSET;
  4. public static final int ARRAY_BYTE_BASE_OFFSET;
  5. public static final int ARRAY_SHORT_BASE_OFFSET;
  6. public static final int ARRAY_CHAR_BASE_OFFSET;
  7. public static final int ARRAY_INT_BASE_OFFSET;
  8. public static final int ARRAY_LONG_BASE_OFFSET;
  9. public static final int ARRAY_FLOAT_BASE_OFFSET;
  10. public static final int ARRAY_DOUBLE_BASE_OFFSET;
  11. public static final int ARRAY_OBJECT_BASE_OFFSET;
  12. public static final int ARRAY_BOOLEAN_INDEX_SCALE;
  13. public static final int ARRAY_BYTE_INDEX_SCALE;
  14. public static final int ARRAY_SHORT_INDEX_SCALE;
  15. public static final int ARRAY_CHAR_INDEX_SCALE;
  16. public static final int ARRAY_INT_INDEX_SCALE;
  17. public static final int ARRAY_LONG_INDEX_SCALE;
  18. public static final int ARRAY_FLOAT_INDEX_SCALE;
  19. public static final int ARRAY_DOUBLE_INDEX_SCALE;
  20. public static final int ARRAY_OBJECT_INDEX_SCALE;
  21. public static final int ADDRESS_SIZE;
  23. private static native void registerNatives();
  25. static {
  26.     registerNatives();
  27.     Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
  28.     theUnsafe = new Unsafe();//单例模式 -饿汉式
  29.     ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset(boolean[].class);
  30.     ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset(byte[].class);
  31.     ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset(short[].class);
  32.     ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset(char[].class);
  33.     ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset(int[].class);
  34.     ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset(long[].class);
  35.     ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset(float[].class);
  36.     ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset(double[].class);
  37.     ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset(Object[].class);
  38.     ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale(boolean[].class);
  39.     ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale(byte[].class);
  40.     ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale(short[].class);
  41.     ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale(char[].class);
  42.     ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale(int[].class);
  43.     ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale(long[].class);
  44.     ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale(float[].class);
  45.     ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale(double[].class);
  46.     ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale(Object[].class);
  47.     ADDRESS_SIZE = theUnsafe.addressSize();
  48. }

3.Unsafe重要方法

  1. //获得给定对象内存偏移量的int值
  2. public native int getInt(Object var1, long var2);
  3. //设置给定对象内存偏移量的int值
  4. public native void putInt(Object var1, long var2, int var4);
  5. public native Object getObject(Object var1, long var2);
  6. public native void putObject(Object var1, long var2, Object var4);
  7. //....还有Boolean、Byte、Char、Short、Long、Float、Double的get\set....
  8. //内存分配、释放
  9. //分配内存
  10. public native long allocateMemory(long var1);
  11. //扩充内存
  12. public native long reallocateMemory(long var1, long var3);
  13. public native void setMemory(Object var1, long var2, long var4, byte var6);
  14. public void setMemory(long var1, long var3, byte var5) {
  15.     this.setMemory((Object)null, var1, var3, var5);
  16. }
  17. //拷贝内存
  18. public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);
  19. public void copyMemory(long var1, long var3, long var5) {
  20.     this.copyMemory((Object)null, var1, (Object)null, var3, var5);
  21. }
  22. //释放内存
  23. public native void freeMemory(long var1);
  24. //获取字段在对象中的内存偏移量
  25. public native long staticFieldOffset(Field var1);
  26. public native long objectFieldOffset(Field var1);
  27. public native Object staticFieldBase(Field var1);
  28. public native void ensureClassInitialized(Class<?> var1);
  29. //数组元素定位
  30. //arrayBaseOffset 和 arrayIndexScale 搭配使用可以定位数组中每个元素在内存中的位置
  31. //获取数组第一个元素的偏移地址
  32. public native int arrayBaseOffset(Class<?> var1);
  33. //获取数组的转换因子，也就是数组中元素的增量地址
  34. public native int arrayIndexScale(Class<?> var1);
  35. public native int addressSize();
  36. public native int pageSize();
  37. //类定义
  38. public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);
  39. public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4);
  40. public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3);
  41. //创建实例
  42. public native Object allocateInstance(Class<?> var1) throws InstantiationException;
  43. //Synchronized同步块的指令实现 1.8版的全部是@Deprecated
  44. public native void monitorEnter(Object var1);
  45. public native void monitorExit(Object var1);
  46. public native boolean tryMonitorEnter(Object var1);
  47. //异常抛出
  48. public native void throwException(Throwable var1);
  49. //CAS操作
  50. /**
  51. * 比较obj的offset处内存位置中的值和期望的值，如果相同则更新，此更新是不可中断的
  52. * @param obj 需要更新的对象
  53. * @param offset obj中整型field的偏移量
  54. * @param expect 希望field中存在的值
  55. * @param update 如果期望值expect与field的当前值相同，设置filed的值为这个新值
  56. * @return 如果field的值被更改返回true
  57. */
  58. public final native boolean compareAndSwapObject(Object obj, long offset, Object expect, Object update);
  59. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5);
  60. public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
  61. //获取给定对象的指定类型值，支持volatile load语义
  62. public native Object getObjectVolatile(Object var1, long var2);
  63. public native void putObjectVolatile(Object var1, long var2, Object var4);
  64. public native int getIntVolatile(Object var1, long var2);
  65. //设置给定对象的int值，支持volatile load语义
  66. public native void putIntVolatile(Object var1, long var2, int var4);
  67. //....还有Boolean、Byte、Char、Short、Long、Float、Double的volatile级别的get\put....
  68. public native void putDoubleVolatile(Object var1, long var2, double var4);
  69. public native void putOrderedObject(Object var1, long var2, Object var4);
  70. public native void putOrderedInt(Object var1, long var2, int var4);
  71. public native void putOrderedLong(Object var1, long var2, long var4);
  72. //LockSupport类的原语支持-挂起和唤醒某个线程
  73. public native void unpark(Object var1);
  74. public native void park(boolean var1, long var2);
  75. public native int getLoadAverage(double[] var1, int var2);
  76. //提供线程安全的add和set操作
  77. public final int getAndAddInt(Object var1, long var2, int var4) {
  78. int var5;
  79.     do {
  80.         var5 = this.getIntVolatile(var1, var2);
  81.     } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4));
  82.     return var5;
  83. }
  84. public final int getAndSetInt(Object var1, long var2, int var4) {
  85.     int var5;
  86.     do {
  87.         var5 = this.getIntVolatile(var1, var2);
  88.     } while(!this.compareAndSwapInt(var1, var2, var5, var4));
  89.     return var5;
  90. }
  91. //...还有Long和Object的线程安全的add和set操作...
  92. //栅栏支持
  93. public native void loadFence();
  94. public native void storeFence();
  95. public native void fullFence();

4.Unsafe的使用

4.1 UnSafe的使用限制

  • 由于Unsafe使用风险大，因此JDK增加了很多限制去访问它：即禁止访问的单例模式

4.1.1 私有构造器

  1. private Unsafe() {}

4.1.2 禁用的工厂方法

  1. @CallerSensitive
  2. public static Unsafe getUnsafe() {
  3.     Class var0 = Reflection.getCallerClass();
  4.     //该方法用于判断调用者的类加载器是否是系统核心加载器（即Bootstrap加载器）
  5.     if(!VM.isSystemDomainLoader(var0.getClassLoader())) {
  6.         throw new SecurityException("Unsafe");
  7.     } else {
  8.         return theUnsafe;
  9.     }
  10. }
  1. package concurrent;
  2. import sun.misc.Unsafe;
  3. public class UnsafeDemo {
  4.     public static void main(String[] args) {
  5.         Unsafe.getUnsafe();
  6.     }
  7. }
  8. -------------------
  9. //输出：
  10. Exception in thread "main" java.lang.SecurityException: Unsafe
  11.     at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)
  12.     at concurrent.UnsafeDemo.main(UnsafeDemo.java:7)
  13. //分析：可以发现直接调用的话会直接抛出安全异常，原因是类加载器是AppClassLoader而并非是BootstrapLoader

QQ截图20170830155001.png-60.7kB

  • 根据Java 类加载器的工作原理，应用程序的类由AppLoader加载，而系统核心类由BootstrapLoader加载
  • 当一个类的类加载器为null时，说明它是由BootstrapLoader加载的，即此类是系统核心类(比如rt.jar包中的类)
  • 当一个类无法被BootstrapLoader加载时，其类加载器通常为AppClassLoader，即是属于自定义类

4.2 Unsafe的反射获取

  1. /** 
  2.   * 我们可以通过反射机制获取Unsafe 的一个实例
  3.   */
  4. public static Unsafe getUnsafe(){
  5.     try {
  6.         //通过反射获取Unsafe的theUnsafe变量，即Unsafe实例对象
  7.         Field f = Unsafe.class.getDeclaredField("theUnsafe");
  8.         f.setAccessible(true);
  9.         //注意field是static属性
  10.         //参见：private static final Unsafe theUnsafe;
  11.         return (Unsafe) f.get(null);
  12.     } catch (Exception e) {
  13.         e.printStackTrace();
  14.     }
  15.     return null;
  16. }

并发番@Unsafe一文通(1.8版) 由 黄志鹏kira 创作，采用 知识共享 署名-非商业性使用 4.0 国际 许可协议 进行许可。

本站文章除注明转载/出处外，均为本站原创或翻译，转载前请务必署名。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注