zoukankan      html  css  js  c++  java
  • 一个名为不安全的类Unsafe

    最近为了更加深入了解NIO的实现原理,学习NIO的源码时,遇到了一个问题。即在WindowsSelectorImpl中的

    pollWrapper属性,当我点进去查看它的PollArrayWrapper类型时,发现它和AllocatedNativeObject类型有关,而AllocatedNativeObject继承了NativeObject类,随着又发现了NativeObject是基于一个Unsafe类实现的。不安全的类????

     

    Unsafe

    Unsafe,顾名思义,它真是一个不安全的类,那它为什么是不安全的呢?这就要从Unsafe类的功能说起。

    学过C#的就可以知道,C#和Java的一个重要区别就是:C#可以直接操作一块内存区域,如自己申请内存和释放,而在Java中这是做不到的。而Unsafe类就可以让我们在Java中像C#一样去直接操作一块内存区域,正因为Unsafe类可以直接操作内存,意味着其速度更快,在高并发的条件之下能够很好地提高效率,所以java中很多并发框架,如Netty,都使用了Unsafe类。

    虽然,Unsafe可以提高运行速度,但是因为Java本身是不支持自己直接操作内存的,这就意味着Unsafe类所做的操作不受jvm管理的,所以不会被GC(垃圾回收),需要我们手动GC,稍有不慎就会出现内存泄漏问题。且Unsafe的不少方法中必须提供原始地址(内存地址)和被替换对象的地址,偏移量要自己计算,一旦出现问题就是JVM崩溃级别的异常,会导致整个JVM实例崩溃。这就是为什么Unsafe被称为不安全的原因。Unsafe可以让你全力踩油门,提高自己的速度,但是它会让你的方向盘更难握稳,一不小心就可能导致车毁人亡。

    源码查看

    初始化

    因为Unsafe的构造方法是private类型的,所以无法通过new方式实例化获取,只能通过它的getUnsafe()方法获取。又因为Unsafe是直接操作内存的,为了安全起见,Java的开发人员为Unsafe的获取设置了限制,所以想要获取它只能通过Java的反射机制来获取。

    @CallerSensitive
    public static Unsafe getUnsafe() {
        //通过getCallerClass方法获取Unsafe类
        Class var0 = Reflection.getCallerClass();
        //如过该var0类不是启动类加载器(Bootstrap),则抛出异常
        //正因为该判断,所以Unsafe只能通过反射获取
        if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
            throw new SecurityException("Unsafe");
        } else {
            return theUnsafe;
        }
    }
    • Reflection.getCallerClass():可以返回调用类或Reflection类,或者层层上传

    • VM.isSystemDomainLoader(ClassLoader var0):判断该类加载器是否是启动类加载器(Bootstrap)。

    • @CallerSensitive:为了防止黑客通过双重反射来提升权限,所以所有跟反射相关的接口方法都标注上CallerSensitive

    所以使用下面的方式是获取不了Unsafe类的:

    //使用这样的方式获取会抛出异常,因为是通过系统类加载器加载(AppClassLoader)
    public class Test {
        public static void main(String[] args) {
            Unsafe unsafe = Unsafe.getUnsafe();
        }
    }

    那怎么才用使用启动类加载Unsafe类并获取它呢?在Unsafe类的最下面的static代码块中有这样一段代码:

    private static final Unsafe theUnsafe;
    //.....
    static {
        registerNatives();
        Reflection.registerMethodsToFilter(Unsafe.class, new String[]{"getUnsafe"});
        theUnsafe = new Unsafe();
        //......
    }

    学过反射机制看过以上代码就可以知道我们可以通过getDeclaredField()返回获取Un safe类的theUnsafe属性,然后通过该属性获取Unsafe类的实例,因为在Unsafe类里的theUnsafe属性已经被new实例化了。

    public class Test {
        public static void main(String[] args) throws Exception {
            //通过getDeclaredField方法获取Unsafe类中名为theUnsafe的属性
            //注意,该属性是private类型的,所以不能用getField获取,只能用getDeclaredField
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            //将该属性设为可访问
            field.setAccessible(true);
            //实例该属性并转为Unsafe类型
            //因为theUnsafe属性是Unsafe类所在的包的启动类加载的,所以可以成功获得
            Unsafe unsafe = (Unsafe)field.get(null);
        }
    }

    获取偏移量方法

    偏移量

    在实际模式中,内存是被分成段的,如果想要获取内存中的某个储存单元,需知道储存单元的所在段地址(段头)和偏移量,即使你知道该储存单元的实际地址。而偏移量就是实际地址与所在段地址(段头)的距离,偏移量=实际地址-所在段地址(段头)

    举个例子,假设有个书架,我需要找由左到右、由上到下数的第1024本书,那我只能一本本的数,直到数到第1024本,但如果我知道书架的第4层的第一本书是第1000本书,那我只用从第1000本书开始数,数到1024,只需数1024-1000=24本。在这里,书架是内存,要找的书就是储存单元,书架的第4层就是内存段,第4层的第一本书即书架的第1000本书就是段地址(段头),第1024本书就是实际地址,而偏移量的就是第1000本书到第1024本书的距离24.

    public native long objectFieldOffset(Field var1);

    获取非静态变量var1的偏移量。

    public native long staticFieldOffset(Field var1);

    获取静态变量var1的偏移量。

    public native Object staticFieldBase(Field var1);

    获取静态变量var1的实际地址,配合staticFieldOffset方法使用,可求出变量所在的段地址

    public native int arrayBaseOffset(Class<?> var1);

    获取数组var1中的第一个元素的偏移量,即数组的基础地址。

    在内存中,数组的存储是以一定的偏移量增量连续储存的,如数组的第一个元素的实际地址为24,偏移量为4,而数组的偏移量增量为1,那数组的第二个元素的实际地址就是25,偏移量为5.

    public native int arrayIndexScale(Class<?> var1);

    获取数组var1的偏移量增量。结合arrayBaseOffset(Class<?> var1)方法就可以求出数组中各个元素的地址。

     

    操作属性方法

    public native Object getObject(Object var1, long var2);

    获取var1对象中偏移量为var2的Object对象,该方法可以无视修饰符限制。相同方法有getInt、getLong、getBoolean等。

    public native void putObject(Object var1, long var2, Object var4);

    将var1对象中偏移量为var2的Object对象的值设为var4,该方法可以无视修饰符限制。相同的方法有putInt、putLong、putBoolean等。

    public native Object getObjectVolatile(Object var1, long var2);

    功能与getObject(Object var1, long var2)一样,但该方法可以保证读写的可见性和有序性,可以无视修饰符限制。相同的方法有getIntVolatile、getLongVolatile、getBooleanVolatile等。

    public native void putObjectVolatile(Object var1, long var2, Object var4);

    功能与putObject(Object var1, long var2, Object var4)一样,但该方法可以保证读写的可见性和有序性,可以无视修饰符限制。相同的方法有putIntVolatile、putLongVolatile、putBooleanVolatile等。

    public native void putOrderedObject(Object var1, long var2, Object var4);

    功能与putObject(Object var1, long var2, Object var4)一样,但该方法可以保证读写的有序性(不保证可见性),可以无视修饰符限制。相同的方法有putOrderedInt、putOrderedLong等。

     

    操作内存方法

    public native int addressSize();

    获取本地指针大小,单位为byte,通常值为4或8。

    public native int pageSize();

    获取本地内存的页数,该返回值会是2的幂次方。

    public native long allocateMemory(long var1);

    开辟一块新的内存块,大小为var1(单位为byte),返回新开辟的内存块地址。

    public native long reallocateMemory(long var1, long var3);

    将内存地址为var3的内存块大小调整为var1(单位为byte),返回调整后新的内存块地址。

    public native void setMemory(long var2, long var4, byte var6);

    从实际地址var2开始将后面的字节都修改为var6,修改大小为var4(通常为0)。

    public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);

    从对象var1中偏移量为var2的地址开始复制,复制到var4中偏移量为var5的地址,复制大小为var7。

    当var1为空时,var2就不是偏移量而是实际地址,当var4为空时,var5就不是偏移量而是实际地址。

    public native void freeMemory(long var1);

    释放实际地址为var1的内存。

     

    线程挂起和恢复方法

    public native void unpark(Object var1);

    将被挂起的线程var1恢复,由于其不安全性,需保证线程var1是存活的。

    public native void park(boolean var1, long var2);

    当var2等于0时,线程会一直挂起,知道调用unpark方法才能恢复。

    当var2大于0时,如果var1为false,这时var2为增量时间,即线程在被挂起var2秒后会自动恢复,如果var1为true,这时var2为绝对时间,即线程被挂起后,得到具体的时间var2后才自动恢复。

     

    CAS方法

    public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5);

    CAS机制相关操作,对对象var1里偏移量为var2的变量进行CAS修改,var4为期待值,var5为修改值,返回修改结果。相同方法有compareAndSwapInt、compareAndSwapLong。

     

    类加载方法

    public native boolean shouldBeInitialized(Class<?> var1);

    判断var1类是否被初始。

    public native void ensureClassInitialized(Class<?> var1);

    确保var1类已经被初始化。

    public native Class<?> defineClass(String var1, byte[] var2, int var3, int var4, ClassLoader var5, ProtectionDomain var6);

    定义一个类,用于动态的创建类。var1为类名,var2为类的文件数据字节数组,var3为var2的输入起点,var4为输入长度,var5为加载该类的加载器,var6为保护领域。返回创建后的类。

    public native Class<?> defineAnonymousClass(Class<?> var1, byte[] var2, Object[] var3);

    用于动态的创建匿名内部类。var1为需创建匿名内部类的类,var2为匿名内部类的文件数据字节数组,var3为修补对象。返回创建后的匿名内部类。

    public native Object allocateInstance(Class<?> var1) throws InstantiationException;

    创建var1类的实例,但是不会调用var1类的构造方法,如果var1类还没有初始化,则进行初始化。返回创建实例对象。

    内存屏障方法

    public native void loadFence();

    所有读操作必须在loadFence方法执行前执行完毕。

    public native void storeFence();

    所有写操作必须在storeFence方法执行前执行完毕。

    public native void fullFence();

    所有读写操作必须在fullFence方法执行前执行完毕。

    疑惑

    看到这里可能有人会有一个疑惑,为什么这些方法都没有具体的功能实现代码呢?

    在文章开头时就说过,Java不支持直接操作内存,那怎么可能用Java来具体实现功能呢。你可以发现Unsafe类内的大多方法都有native修饰符,native接口可以让你调用本地的代码文件(包括其他语言,如c语言),既然Java实现不了,那就让能实现的人来做,所以Unsafe的底层实现语言其实是C语言,这也是为什么Unsafe类内会有偏移量和指针这些Java中没有的概念了。

     

    (以上为本人自己对Unsafe类的理解,如果有错误,欢迎各位前辈指出)

     

  • 相关阅读:
    对象的方法
    uni-app运行
    flex取值
    阿里矢量库使用
    移动端vue项目模板
    微信分享--转载
    页面流动条
    uni-app打包
    Hibernate~DAO
    EL表达式
  • 原文地址:https://www.cnblogs.com/gaofei200/p/13951764.html
Copyright © 2011-2022 走看看