[JUC] sun.misc.Unsafe的原理【转载】

最新推荐文章于 2024-01-27 12:04:25 发布

goalietang

最新推荐文章于 2024-01-27 12:04:25 发布

阅读量167

点赞数

分类专栏：并发编程 javaSE 文章标签：高并发 juc java

原文链接：https://blog.youkuaiyun.com/zyzzxycj/article/details/89877863

版权

javaSE 同时被 2 个专栏收录

9 篇文章

订阅专栏

并发编程

6 篇文章

订阅专栏

Unsafe类是Java中的一个强大工具，它提供了内存分配、对象字段访问、类加载等底层操作。通过Unsafe，可以实现高效的数据结构、内存管理、并发优化等。例如，它可以用于动态分配内存、修改对象字段值、实现浅复制、创建大数组、动态加载类、无锁数据结构等。然而，由于其潜在的风险，如内存泄漏和非法访问，使用时需谨慎。在并发场景下，Unsafe的compareAndSwap方法可以用于实现原子操作，提高性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是Unsafe

Unsafe类在JDK源码中被广泛使用，在Spark使用off-heap memory时也会使用到，该类功能很强大，涉及到类加载机制，其实例一般情况是获取不到的，源码中的设计是采用单例模式，不是系统加载初始化就会抛出SecurityException异常。

这个类的提供了一些绕开JVM的更底层功能，基于它的实现可以提高效率。（通常是直接操作内存）但是，它是一把双刃剑：正如它的名字所预示的那样，它是Unsafe的，它所分配的内存需要手动free（不被GC回收）。如果对Unsafe类理解的不够透彻，就进行使用的话，就等于给自己挖了无形之坑，最为致命。

Unsafe类中的核心方法

     //重新分配内存
     public native long reallocateMemory(long address, long bytes);  
     //分配内存  
     public native long allocateMemory(long bytes);  
     //释放内存  
     public native void freeMemory(long address);  
     //在给定的内存块中设置值  
     public native void setMemory(Object o, long offset, long bytes, byte value);  
     //从一个内存块拷贝到另一个内存块  
     public native void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes);  
     //获取值，不管java的访问限制，其他有类似的getInt，getDouble，getLong，getChar等等  
     public native Object getObject(Object o, long offset);  
     //设置值，不管java的访问限制，其他有类似的putInt,putDouble，putLong，putChar等等  
     public native void putObject(Object o, long offset);  
     //从一个给定的内存地址获取本地指针，如果不是allocateMemory方法的，结果将不确定  
     public native long getAddress(long address);  
     //存储一个本地指针到一个给定的内存地址,如果地址不是allocateMemory方法的，结果将不确定  
     public native void putAddress(long address, long x);  
     //该方法返回给定field的内存地址偏移量，这个值对于给定的filed是唯一的且是固定不变的  
     public native long staticFieldOffset(Field f);  
     //报告一个给定的字段的位置，不管这个字段是private，public还是保护类型，和staticFieldBase结合使用  
     public native long objectFieldOffset(Field f);  
     //获取一个给定字段的位置  
     public native Object staticFieldBase(Field f);  
     //确保给定class被初始化，这往往需要结合基类的静态域（field）  
     public native void ensureClassInitialized(Class c);  
     //可以获取数组第一个元素的偏移地址  
     public native int arrayBaseOffset(Class arrayClass);  
     //可以获取数组的转换因子，也就是数组中元素的增量地址。将arrayBaseOffset与arrayIndexScale配合使用， 可以定位数组中每个元素在内存中的位置  
     public native int arrayIndexScale(Class arrayClass);  
     //获取本机内存的页数，这个值永远都是2的幂次方  
     public native int pageSize();  
     //告诉虚拟机定义了一个没有安全检查的类，默认情况下这个类加载器和保护域来着调用者类  
     public native Class defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain);  
     //定义一个类，但是不让它知道类加载器和系统字典  
     public native Class defineAnonymousClass(Class hostClass, byte[] data, Object[] cpPatches);  
     //锁定对象，必须是没有被锁的
     public native void monitorEnter(Object o);   
     //解锁对象  
     public native void monitorExit(Object o);  
     //试图锁定对象，返回true或false是否锁定成功，如果锁定，必须用monitorExit解锁  
     public native boolean tryMonitorEnter(Object o);  
     //引发异常，没有通知  
     public native void throwException(Throwable ee);  
     //CAS，如果对象偏移量上的值=期待值，更新为x,返回true.否则false.类似的有compareAndSwapInt,compareAndSwapLong,compareAndSwapBoolean,compareAndSwapChar等等。  
     public final native boolean compareAndSwapObject(Object o, long offset,  Object expected, Object x);  
     // 该方法获取对象中offset偏移地址对应的整型field的值,支持volatile load语义。类似的方法有getIntVolatile，getBooleanVolatile等等  
     public native Object getObjectVolatile(Object o, long offset);   
     //线程调用该方法，线程将一直阻塞直到超时，或者是中断条件出现。  
     public native void park(boolean isAbsolute, long time);  
     //终止挂起的线程，恢复正常.java.util.concurrent包中挂起操作都是在LockSupport类实现的，也正是使用这两个方法
     public native void unpark(Object thread);  
     //获取系统在不同时间系统的负载情况  
     public native int getLoadAverage(double[] loadavg, int nelems);  
     //创建一个类的实例，不需要调用它的构造函数、初使化代码、各种JVM安全检查以及其它的一些底层的东西。即使构造函数是私有，我们也可以通过这个方法创建它的实例,对于单例模式，简直是噩梦。 
     public native Object allocateInstance(Class cls) throws InstantiationException;

总的来说就是这么几类

（1）Info相关。主要返回某些低级别的内存信息：addressSize(), pageSize()

（2）Objects相关。主要提供Object和它的域操纵方法：allocateInstance(),objectFieldOffset()

（3）Class相关。主要提供Class和它的静态域操纵方法：staticFieldOffset(),defineClass(),defineAnonymousClass(),ensureClassInitialized()

（4）Arrays相关。数组操纵方法：arrayBaseOffset(),arrayIndexScale()

（5）Synchronization相关。主要提供低级别同步原语（如基于CPU的CAS（Compare-And-Swap）原语）：monitorEnter(),tryMonitorEnter(),monitorExit(),compareAndSwapInt(),putOrderedInt()

（6）Memory相关。直接内存访问方法（绕过JVM堆直接操纵本地内存）：allocateMemory(),copyMemory(),freeMemory(),getAddress(),getInt(),putInt()

Unsafe该怎么用？

1、Unsafe.allocateInstance

public static void main(String[] args) throws Exception {
        //反射获取unsafe对象。（只能反射获得）
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        
        //普通new方法获取对象。会调用构造方法
        A o1 = new A(); // constructor
        System.out.println(o1.a());
        //反射获取对象，如果对象的构造方法私有，是无法获取的。
        A o2 = A.class.newInstance(); // reflection
        System.out.println(o2.a());
        //通过unsafe的allocateInstance获取对象，不会进入构造方法。
        //所以这里a方法返回的a值为经过构造器初始化。为0
        A o3 = (A) unsafe.allocateInstance(A.class); // unsafe
        System.out.println(o3.a());
    }

    static class A {
        private long a; // not initialized value, default 0
        public A() {
            this.a = 1; // initialization
        }
        public long a() {
            return this.a;
        }
    }

2、内存修改，绕过安全检查器（Unsafe.objectFieldOffset）

public static void main(String[] args) throws Exception {
        //通过反射获取unsafe对象
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        
        //n创建Guard对象，调用giveAccess，会发现返回false，
        //因为ACCESS_ALLOWED初始化为1，并不是获得权限的42.
        Guard guard = new Guard();
        guard.giveAccess();   // false, no access


        // 通过反射获取ACCESS_ALLOWED字段，
        Field field = guard.getClass().getDeclaredField("ACCESS_ALLOWED");
        //通过unsafe方法将ACCESS_ALLOWED的值改为42
        unsafe.putInt(guard, unsafe.objectFieldOffset(field), 42);
        //返回true，获得权限。
        guard.giveAccess(); // true, access granted
    }

    static class Guard {
        private int ACCESS_ALLOWED = 1;
        public boolean giveAccess() {
            return 42 == ACCESS_ALLOWED;
        }
    }

通过获取目标对象的字段在内存中的offset，并使用putInt()方法，类的ACCESS_ALLOWED被修改。在已知类结构的时候，数据的偏移总是可以获得的（与c++中的类中数据的偏移计算是一致的）。

3、sizeOf 计算内存大小（Unsafe.getDeclaredFields和Unsafe.objectFieldOffset）

public static void main(String[] args) throws Exception {
        Guard guard = new Guard();
        sizeOf(guard); // 16, the size of guard
    }

    static class Guard {
        private int ACCESS_ALLOWED = 1;
        public boolean giveAccess() {
            return 42 == ACCESS_ALLOWED;
        }
    }

    public static long sizeOf(Object o) throws Exception {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);

        
        HashSet<Field> fields = new HashSet();
        Class c = o.getClass();
        while (c != Object.class) {
            for (Field field : c.getDeclaredFields()) {
                if ((field.getModifiers() & Modifier.STATIC) == 0) {
                    fields.add(field);
                }
            }
            c = c.getSuperclass();
        }

        // get offset
        long maxSize = 0;
        for (Field field : fields) {
            long offset = unsafe.objectFieldOffset(field);
            if (offset > maxSize) {
                maxSize = offset;
            }
        }
        return ((maxSize/8) + 1) * 8;   // padding
    }

从底层子类开始，依次取出它自己和它的所有超类的非静态域，放置到一个HashSet中（重复的只计算一次，Java是单继承），然后使用objectFieldOffset()获得一个最大偏移，最后还考虑了对齐。

4、实现Java浅复制

public static void main(String[] args) throws Exception {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        unsafe = (Unsafe) f.get(null);
        Guard guard = new Guard();
        shallowCopy(guard);
    }

    private static Unsafe getUnsafe() {
        return unsafe;
    }

    static Object shallowCopy(Object obj) throws Exception {
        long size = sizeOf(obj);
        long start = toAddress(obj);
        long address = getUnsafe().allocateMemory(size);
        getUnsafe().copyMemory(start, address, size);
        return fromAddress(address);
    }

    static long toAddress(Object obj) {
        Object[] array = new Object[]{obj};
        long baseOffset = getUnsafe().arrayBaseOffset(Object[].class);
        return normalize(getUnsafe().getLong(array, baseOffset));
    }

    static Object fromAddress(long address) {
        Object[] array = new Object[] {null};
        long baseOffset = getUnsafe().arrayBaseOffset(Object[].class);
        getUnsafe().putLong(array, baseOffset, address);
        return array[0];
    }

    static class Guard {
        private int ACCESS_ALLOWED = 1;
        public boolean giveAccess() {
            return 42 == ACCESS_ALLOWED;
        }
    }

    public static long sizeOf(Object o) throws Exception {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);

        HashSet<Field> fields = new HashSet();
        Class c = o.getClass();
        while (c != Object.class) {
            for (Field field : c.getDeclaredFields()) {
                if ((field.getModifiers() & Modifier.STATIC) == 0) {
                    fields.add(field);
                }
            }
            c = c.getSuperclass();
        }

        // get offset
        long maxSize = 0;
        for (Field field : fields) {
            long offset = unsafe.objectFieldOffset(field);
            if (offset > maxSize) {
                maxSize = offset;
            }
        }
        return ((maxSize / 8) + 1) * 8;   // padding
    }
}

思路很简单，利用Unsafe.copyMemory()，将老地址及其指向的对象的size，拷贝到新的内存地址上。并且浅复制函数可以应用于任意java对象，它的尺寸是动态计算的。

5、隐藏密码

一般密码都要存成byte[]或者char[]数组，为什么呢？？
因为我们使用完了，可以直接将他们设为null。但如果密码存在String中，将其设为null，密码实际任然存在在内存中，等到GC后，才能被释放，就很不安全。
所以当我们把密码字段存储在String中时，在密码字段使用完之后，最安全的做法是：将它的值覆盖。很多不再需要的，但是又是比较机密的对象，想快点消灭证据，都可以通过这种方法来消除。

Field stringValue = String.class.getDeclaredField("value");
    stringValue.setAccessible(true);
    char[] mem = (char[]) stringValue.get(password);
    for (int i = 0; i < mem.length; i++) {
        mem[i] = '?';
    }

6、实现多继承

在java中没有多继承，除非我们能在这些不同的类互相强制转换。

long intClassAddress = normalize(getUnsafe().getInt(new Integer(0), 4L));
long strClassAddress = normalize(getUnsafe().getInt("", 4L));
getUnsafe().putAddress(intClassAddress + 36, strClassAddress);

上面这段代码将String添加为int的父类，所以我们转换的时候就不会报错了。

(String) (Object) (new Integer(666))

7、动态加载类

标准的动态加载类的方法是Class.forName()，使用Unsafe也可以动态加载java的class文件。
我们可以在程序运行是动态加载编译好的.class文件

// 我们首先读取一个class文件到byte数组中
byte[] classContents = getClassContent();
// 然后通过Unsafe.defineClass()来加载对应的Class
Class c = getUnsafe().defineClass(
              null, classContents, 0, classContents.length);
// 最后调用
c.getMethod("a").invoke(c.newInstance(), null); // 1
    
private static byte[] getClassContent() throws Exception {
    File f = new File("/home/mishadoff/tmp/A.class");
    FileInputStream input = new FileInputStream(f);
    byte[] content = new byte[(int)f.length()];
    input.read(content);
    input.close();
    return content;
}

8、大数组

Java的数组最大容量受常量Integer.MAX_VALUE的限制，如果我们用直接申请内存的方式去创建数组，那么数组大小只会受到堆的大小的限制。

private static Unsafe unsafe;
    
    public static void main(String[] args) throws Exception {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        unsafe = (Unsafe) f.get(null);
        // 设置数组大小为Integer.MAX_VALUE的2倍
        long SUPER_SIZE = (long) Integer.MAX_VALUE * 2;
        SuperArray array = new SuperArray(SUPER_SIZE);
        System.out.println("Array size:" + array.size()); // 4294967294
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            array.set((long) Integer.MAX_VALUE + i, (byte) 3);
            sum += array.get((long) Integer.MAX_VALUE + i);
        }
        System.out.println("Sum of 100 elements:" + sum);  // 300
    }

    private static Unsafe getUnsafe() {
        return unsafe;
    }

    static class SuperArray {
        private final static int BYTE = 1;
        private long size;
        private long address;

        public SuperArray(long size) {
            this.size = size;
            address = getUnsafe().allocateMemory(size * BYTE);
        }
        public void set(long i, byte value) {
            getUnsafe().putByte(address + i * BYTE, value);
        }
        public int get(long idx) {
            return getUnsafe().getByte(address + idx * BYTE);
        }
        public long size() {
            return size;
        }
    }

输出结果：

9、在非Java堆中分配内存

使用java 的new创建对象，会在堆中为对象分配内存，并且在对象的生命周期内，会被JVM GC管理。Unsafe分配的内存，不受Integer.MAX_VALUE的限制，并且分配在非堆内存，使用它时，需要非常谨慎：忘记手动回收时，会产生内存泄露；非法的地址访问时，会导致JVM崩溃。在需要分配大的连续区域、实时编程（不能容忍JVM延迟）时，可以使用它。java.nio使用这一技术。（详情可见例8里面创建大数组）

10、Java并发中的应用

通过使用Unsafe.compareAndSwap()可以用来实现高效的无锁数据结构。

class CASCounter implements Counter {
 private volatile long counter = 0;
 private Unsafe unsafe;
 private long offset;
 
 public CASCounter() throws Exception {
  unsafe = getUnsafe();
  offset = unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("counter"));
 }
 
 @Override
 public void increment() {
  long before = counter;
  while (!unsafe.compareAndSwapLong(this, offset, before, before + 1)) {
   before = counter;
  }
 }
 
 @Override
 public long getCounter() {
  return counter;
 }
}

通过测试，以上数据结构与java的原子变量的效率基本一致，Java原子变量也使用Unsafe的compareAndSwap()方法，而这个方法最终会对应到cpu的对应原语，因此，它的效率非常高。这里有一个实现无锁HashMap的方案（http://www.azulsystems.com/about_us/presentations/lock-free-hash ，这个方案的思路是：分析各个状态，创建拷贝，修改拷贝，使用CAS原语，自旋锁），在普通的服务器机器（核心<32），使用ConcurrentHashMap（JDK8以前，默认16路分离锁实现，JDK8中ConcurrentHashMap已经使用无锁实现）明显已经够用。

(才疏学浅，其中很多使用场景都没有理解到位，所以也没有转载过来。剩下的详情可以参考转载博客：https://blog.youkuaiyun.com/zyzzxycj/article/details/89877863)