Java- 并发-Unsafe

﹏ヽ暗。殇╰゛Y 2023-10-09 11:15 36阅读 0赞

## 关于Unsafe类： ##

在java并发相关的源代码学习中，有一个类经常出现，这个类就是位于sun.misc包中的Unsafe类。比如，属于Java并发包中最重要的类之一的AbstractQueuedSynchronizer中就经常调用这个类的方法。

Unsafe类是一个很低级别的类，执行低级别的不安全的操作。所以使用的时候要小心，只有那些获得信任的代码才能调用。为什么说它是比较低级的呢？因为它能直接操作任意的内存。那为什么它是危险的呢？因为它能直接操作任意的内存。

## 获取Unsafe类： ##

Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力，同时也带来了指针的问题。过度的使用Unsafe类会使得出错的几率变大，因此Java官方并不建议使用的，官方文档也几乎没有。

要想使用Unsafe类需要用一些比较tricky的办法。Unsafe类使用了单例模式，需要通过一个静态方法getUnsafe()来获取。但Unsafe类做了限制，如果是普通的调用的话，它会抛出一个SecurityException异常；只有由主类加载器加载的类才能调用这个方法。

compareAndSwapInt举例：

public final native boolean compareAndSwapInt(Object o, long offset,
                                                      int expected,
                                                      int x);

这个方法可以在在对象o的内存偏移offset后与期望值比较，如果等于期望值，就更新为x。由于是直接操作内存的。比如要这样更新一个对象的某个属性，就要得到这个属性在内存中的偏移量。unsafe提供了objectFieldOffset方法来得到某个属性在对象中的偏移量：

public native long objectFieldOffset(Field f);

比如有这个一个对象：

package com.cdmt.java.annotation.historyhandler;
    
    /**
     *
     * @ClassName: User
     **/
    public class User {
        private String id;
    
        private String name;
        private int age;
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "id='" + id + '\'' +
                    ", name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

要得到属性name 偏移量， 就可以使用

nameOffset = unsafe.objectFieldOffset(User.class.getDeclaredField("name"));

还有一些put方法，比如

public native void putOrderedInt(Object obj, long offset, int value);

就是直接把这个对象内存偏移offset然后直接赋int值。

Unsafe类是一个受保护的类，是不能直接在程序中使用的。直接的使用会抛出SecurityException异常，下面来测验一下（import sun.misc.Unsafe 需要手工添加，Eclispe或者其他IDE并不会直接提示）：

import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import sun.misc.Unsafe;
    
    public class UnSafeTest {
        public static void main(String[] args) {
            try {
                Unsafe unsafe = Unsafe.getUnsafe();
                User user = new User();
                long ageOffset = unsafe.objectFieldOffset(filed);
                unsafe.putInt(user, ageOffset, 10);
                System.out.println(user.getAge());
                System.out.println(unsafe);
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

查看获取实例的方法中有一个VM.isSystemDomainLoader检测，如果不是的话，会抛出SecurityException：

@CallerSensitive
        public static Unsafe getUnsafe() {
            Class<?> caller = Reflection.getCallerClass();
            if (!VM.isSystemDomainLoader(caller.getClassLoader()))
                throw new SecurityException("Unsafe");
            return theUnsafe;
        }

来看看M.isSystemDomainLoader内部的方法：

public static boolean isSystemDomainLoader(ClassLoader loader) {
            return loader == null;
        }

在Java中，如果一个对象的classLoader等于null，这就说明这个对象的类加载器是boostrap classloader，那么如果类是由bootstrap classloader加载的话，那么它就是受信任的代码。

可以直接打印String的ClassLoader来检测一下结论是否正确：

`System.out.println(String.class.getClassLoader());`

理论上有两种方法可以打破这种限制。一种就是将User类变成SystemDomainLoader，JAVA本身的类加载机制导致了改变SystemDomainLoader方法暂时较难做到，通用的都是通过反射的方法。一种是通过反射其实体变量theUnsafe：

package com.cdmt.java.annotation.historyhandler;
    import sun.misc.Unsafe;
    
    import java.lang.reflect.Field;
    
    /**
     *
     * @ClassName: UnSafeTest
     **/
    public class UnSafeTest {
        public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
            User user = new User();
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            Unsafe UNSAFE = (Unsafe) theUnsafe.get(null);
            System.out.println(UNSAFE);
            Field filed = user.getClass().getDeclaredField("age");
            long ageOffset = UNSAFE.objectFieldOffset(filed);
            UNSAFE.putInt(user, ageOffset, 10);
            System.out.println(user.getAge());
    
        }
    }

为什么直接操作内存呢？因为速度快。

package com.cdmt.java.annotation.historyhandler;
    
    import sun.misc.Unsafe;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.InvocationTargetException;
    
    /**
     *
     * @ClassName: UnSafeTest2
    
     **/
    public class UnSafeTest2 {
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException, NoSuchMethodException {
            Constructor<Unsafe> con = (Constructor<Unsafe>) Class.forName("sun.misc.Unsafe").getDeclaredConstructor();
            con.setAccessible(true);
            User user = new User();
            Unsafe UNSAFE = con.newInstance(null);
            Field filed = user.getClass().getDeclaredField("age");
            long s1=System.currentTimeMillis();
            for(int i=0;i<1000000000;i++){
                user.setAge(i);
            }
            System.out.println(System.currentTimeMillis()-s1);
            long ageOffset = UNSAFE.objectFieldOffset(filed);
            long s2=System.currentTimeMillis();
            for(int i=0;i<1000000000;i++){
                UNSAFE.putInt(user, ageOffset, i);
            }
            System.out.println(System.currentTimeMillis()-s2);
        }
    }

每个运行10E次计算：

结果：

![20190925095811597.png][]

查了将近10倍

## Unsafe功能： ##

获取到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操作在内存屏障之前完成。

[20190925095811597.png]: https://img-blog.csdnimg.cn/20190925095811597.png