jdk源码(一):你想过用java直接操作内存吗?sun.misc.Unsafe

1、用什么操作内存?

sun.misc.Unsafe 这个类来操作,这个jdk自带的

2、怎么用呢?

如果我们打开这个Unsafe类,你很可能会这样获取,

 Unsafe unsafe = Unsafe.getUnsafe();

但是这样获取不到的,因为这个方法是Caller敏感的,看代码

    @CallerSensitive
    public static Unsafe getUnsafe() {
        Class var0 = Reflection.getCallerClass();
        if (var0.getClassLoader() != null) {
            throw new SecurityException("Unsafe");
        } else {
            return theUnsafe;
        }
    }

从代码中我们发现,只有当前调用这个getUnsafe()方法的类的ClassLoader==null 才可以正常使用,ClassLoader==null意味着调用这个方法的类是jdk中C代码加载的,这里不赘述。

正确的使用方式:使用反射获取,看代码

    public static Unsafe getUnsafe() {
        final Object maybeUnsafe = AccessController.doPrivileged(new PrivilegedAction<Object>() {
            @Override
            public Object run() {
                try {
                    final Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");
                    Throwable cause = ReflectionUtil.trySetAccessible(unsafeField);
                    if (cause != null) {
                        return cause;
                    }
                    // the unsafe instance
                    return unsafeField.get(null);
                } catch (NoSuchFieldException e) {
                    return e;
                } catch (SecurityException e) {
                    return e;
                } catch (IllegalAccessException e) {
                    return e;
                }
            }
        });
        return (Unsafe) maybeUnsafe;
    }

3、使用Unsafe 操作成员变量


    private class UnsafeObject {
        private String fdStr;
        private byte fd_byte;
        private char fd_char;
        private short fd_short;
        private int fd_int;
        private long fd_long;
        private float fd_float;
        private double fd_double;
        private boolean fd_boolean;
    }

    @Test
    public void test() throws NoSuchFieldException, InstantiationException {
        Unsafe unsafe = getUnsafe();

        UnsafeObject unSafeObject = new UnsafeObject();
        // 获取fdStr偏移量
        long fdStrOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fdStr"));
        // 设置变量fdStr=fdStrValue
        unsafe.putOrderedObject(unSafeObject, fdStrOffset, "fdStrValue");
        // 根据对象和偏移量,获取变量fdStr的值
        System.out.println("fdStr = " + unsafe.getObject(unSafeObject, fdStrOffset));
//        unsafe.putObject();

        long fd_byteOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_byte"));
        unsafe.putByte(unSafeObject, fd_byteOffset, (byte) 32);
        System.out.println("fd_byte = " + unsafe.getByte(unSafeObject, fd_byteOffset));

        long fd_charOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_char"));
        unsafe.putChar(unSafeObject, fd_charOffset, 'A');
        System.out.println("fd_char = " + unsafe.getShort(unSafeObject, fd_charOffset));

        long fd_shortOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_short"));
        unsafe.putShort(unSafeObject, fd_shortOffset, (short) 5);
        System.out.println("fd_short = " + unsafe.getShort(unSafeObject, fd_shortOffset));

        long fd_intOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_int"));
        unsafe.putInt(unSafeObject, fd_intOffset, 55555);
        System.out.println("fd_int = " + unsafe.getInt(unSafeObject, fd_intOffset));

        long fd_longOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_long"));
        unsafe.putLong(unSafeObject, fd_longOffset, 12345678901234L);
        System.out.println("fd_long = " + unsafe.getLong(unSafeObject, fd_longOffset));

        long fd_floatOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_float"));
        unsafe.putFloat(unSafeObject, fd_floatOffset, 1333333.5f);
        System.out.println("fd_float = " + unsafe.getFloat(unSafeObject, fd_floatOffset));

        long fd_doubleOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_double"));
        unsafe.putDouble(unSafeObject, fd_doubleOffset, 52533566.555d);
        System.out.println("fd_double = " + unsafe.getDouble(unSafeObject, fd_doubleOffset));

        long fd_booleanOffset = unsafe.objectFieldOffset(UnsafeObject.class.getDeclaredField("fd_boolean"));
        unsafe.putBoolean(unSafeObject, fd_booleanOffset, true);
        System.out.println("fd_boolean = " + unsafe.getBoolean(unSafeObject, fd_booleanOffset));

    }

以上是unsfae.get*()和unsafe.put*() 等操作变量的方法,具体unsfae.get*Volatile(),unsfae.put*Volatile(),只不多是多Volatile语义,关于Volatile 具体可以查看

https://www.ibm.com/developerworks/cn/java/j-jtp06197.html

4、操作数组

    @Test
    public void test4() {
        Unsafe unsafe = getUnsafe();
        Class uoArrClass = UnsafeObject[].class; 
        //  UnsafeObject[]数组基本偏移量
        int uoBase = unsafe.arrayBaseOffset(uoArrClass);
        //  UnsafeObject[]数组单位偏移量,比如:数组[2]的偏移量=基本偏移量+2*单位偏移量
        int uoIndexScale = unsafe.arrayIndexScale(uoArrClass);
        System.out.println("uoBase = " + uoBase);
        System.out.println("uoIndexScale = " + uoIndexScale);
        int arrSize = 8;
        int uoShift = 31 - Integer.numberOfLeadingZeros(uoIndexScale);

        UnsafeObject[] uoArr = new UnsafeObject[arrSize];
        int index = 3; // 数组索引
        long u = (index << uoShift) + uoBase;// 偏移量
        UnsafeObject unsafeObject = new UnsafeObject();
//        System.out.println("unsafeObject = " + unsafeObject);
        // 把数据存放到数组索引=3 中,相当于uoArr[3]=unsafeObject;compareAndSwapObject 是原子操作
        unsafe.compareAndSwapObject(uoArr, u, null, unsafeObject);
        Object object = unsafe.getObjectVolatile(uoArr, u);
        Object object2 = uoArr[index];
//        System.out.println("object = " + object);
//        System.out.println("object2 = " + object2);
        System.out.println("unsafeObject.equals(object) = " + unsafeObject.equals(object));
        System.out.println("unsafeObject.equals(object2) = " + unsafeObject.equals(object2));
    }

如代码操作数组,非常高效,在jdk内部用的非常多,比如ConcurrentHashMap里就用到了

注:UnsafeObject这个类在第3点里

5、内存操作

   @Test
    public void test2() throws InterruptedException {
        Unsafe unsafe = getUnsafe();
        long size = 5;
        long address = unsafe.allocateMemory(size); // 申请内存
        System.out.println(address);

        unsafe.setMemory(address, size, (byte) -1);// 设置内存
        System.out.println(unsafe.getByte(address)); // 根据地址获取数据
        for (int i = 0; i < size; i++) {
            unsafe.putByte(address + i, (byte) i);
        }
        for (int i = 0; i < size; i++) {
            System.out.println(unsafe.getByte(address + i));
        }
        unsafe.freeMemory(address); // 释放内存
    }

6、使用场景

一般的话,讲究极致性能的,我们可以使用unsafe,比如netty就用到了。但是如果使用的话要兼容各个版本的jdk。在业务系统里,不建议使用,如果搞不到很可能导致内存泄露。

7、总结

这个类还没完全分析完,有待更新

为什么要写这个?

主要是在分析ConcurrentHashMap代码时遇到Unsafe,所以就想分析分析,为分析ConcurrentHashMap做准备。

如果想了解ConcurrentHashMap,请关注,后续持续更新。

代码地址:https://github.com/tingliu9/basic-test/blob/master/src/test/java/com/github/tingliu/basic/test/UnsafeTest.java

jdk版本:jdk7_75

如果不对,请赐教!

持续更新有意思的代码

 

 

转载于:https://my.oschina.net/huangy/blog/1620321

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值