简单介绍Java中的Unsafe类

最新推荐文章于 2023-02-14 09:15:07 发布
最新推荐文章于 2023-02-14 09:15:07 发布
阅读量233 收藏
点赞数
分类专栏： JVM 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z28126308/article/details/107718409
版权

概述

sun.misc.Unsafe类旨在仅由核心Java库(JUC包下的类)而非标准用户使用的底层机制，即不推荐开发者使用，但并不妨碍我们对该类的了解。Unsafe可以使Java直接进行内存的操作、实例化类与对实例进行属性操作、提供CAS操作等底层操作，下文将对这些功能进行简单的案例演示，实际开发中依旧不推荐使用，只作为Java体系中的一个知识点了解即可。

Unsafe实例构建

内部类创建Unsafe类实例时都是调用其静态方法getUnsafe()，具体源码如下：

public static Unsafe getUnsafe() {
    Class var0 = Reflection.getCallerClass();
    // 通过ClassLoader判断时内部还是外部调用
    if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
        throw new SecurityException("Unsafe");
    } else {
        return theUnsafe;
    }
}

由于Unsafe是为了内部使用而设计的，所以如果我们直接在程序中调用getUnsafe()时会检测类加载器是内部还是外部，外部将直接报SecurityException异常。当然，我们可以使用反射来获得实例：

Field f = Unsafe.class.getDeclaredField("theUnsafe");
f.setAccessible(true);
unsafe = (Unsafe) f.get(null);

Unsafe对象操作

Java中开发构建实例的方法主要有构造函数、反射、实现Cloneable接口及序列化4种，而Unsafe构建属于官方不推荐使用的，例子如下：

public class UnsafeTest {
    private int number;

    public UnsafeTest() {
        this.number = 1;
    }

    public static void main(String[] args) throws InstantiationException, NoSuchFieldException {
        instanceOperate();
    }
    
    public static void instanceOperate() throws InstantiationException, NoSuchFieldException {
        Unsafe unsafe = getUnsafe();
        UnsafeTest test = (UnsafeTest) unsafe.allocateInstance(UnsafeTest.class);
        // 输出0
        System.out.println(test.number);
    }

    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            return (Unsafe) f.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

除了实例化对象外，Unsafe还可直接操作类属性，如下：

public static void instanceOperate() throws InstantiationException, NoSuchFieldException {
    Unsafe unsafe = getUnsafe();
    UnsafeTest test = (UnsafeTest) unsafe.allocateInstance(UnsafeTest.class);
    // 输出0
    System.out.println(test.number);
    Field numberField = UnsafeTest.class.getDeclaredField("number");
    unsafe.putInt(test, unsafe.objectFieldOffset(numberField), 1);
    // 输出1
    System.out.println(test.number);
}

上例中的UnsafeTest类是没有get与set方法的，Unsafe对属性number的操作是直接到内存根据对象字段元数据获取偏移，找到实例number的属性数据进行操作的，实例数据可参考对象布局(JOL)。

Unsafe操作堆外内存

当应用程序用完了JVM上的可用内存，最终可能会迫使GC进程过于频繁地运行。理想情况下，我们需要一个特殊的内存区域，堆外且不受GC控制。Unsafe类中的allocateMemory()方法能够从堆中分配大对象，这意味着GC和JVM将不会看到并考虑此内存。不过该方法分配的内存需要手动管理，并在不再需要时使用freeMemory()方法正确回收。
例：通过Unsafe直接在内存上创建数组UnsafeTest.OffHeapArray

static class OffHeapArray {
    private final static int BYTE = 1;
    private long size;
    // 内存起始地址
    private long address;
    /**
     * 创建内存数组
     *
     * @param size 分配的内存大小
     */
    public OffHeapArray(long size) {
        this.size = size;
        // 分配内存地址
        address = getUnsafe().allocateMemory(size * BYTE);
    }
    /**
     * 设置起始内存偏移指定下标后的位置值
     *
     * @param i     数组下标，内存偏移量
     * @param value
     */
    public void set(long i, byte value) {
        getUnsafe().putByte(address + i * BYTE, value);
    }
    /**
     * 根据数组下标idx计算在内存中的位置,然后获取数组值
     *
     * @param idx 数组下标，用于计算元素内存相对数组起始地址的偏移量
     * @return
     */
    public int get(long idx) {
        return getUnsafe().getByte(address + idx * BYTE);
    }
    public long size() {
        return size;
    }
    public void freeMemory() {
        getUnsafe().freeMemory(address);
    }
}

// 堆外内存测试方法
public static void offHeapTest() {
    // long SUPER_SIZE = (long) Integer.MAX_VALUE * 2;
    long SUPER_SIZE = Integer.MAX_VALUE;
    OffHeapArray array = new OffHeapArray(SUPER_SIZE);
    int sum = 0;
    for (int i = 0; i < 100; i++) {
        array.set((long) Integer.MAX_VALUE + i, (byte) 1);
        long each = array.get((long) Integer.MAX_VALUE + i);
        sum += each;
    }
    System.out.println("sum:" + sum + ", array.address:" + array.address + ",array.size():" + array.size() + " ,SUPER_SIZE:" + SUPER_SIZE);
    System.out.println(ClassLayout.parseInstance(array).toPrintable());
    array.freeMemory();
}

OffHeapArray是一个通过直接在内存上存取数组的实现类，通过Unsafe的allocateMemory(size)方法获取到分配的内存起始地址，根据分配的内存起始地址计算数组下标在内存中的实际地址。单看以上程序是无法看出分配的内存是在堆上还是堆外的，可以通过参数-VM:-PrintGCDetails并更改分配的内存大小size后对比size更改前后的堆大小变化。

  1. size = Integer.MAX_VALUE,i < 100,GCPrint如下：
    Unsafe_offHeap_1.png

  2. size = Integer.MAX_VALUE * 2, i < 1000,GCPrint如下：
    Unsafe_offHeap_2.png

CAS操作

java.concurrent包中的CAS操作(如AtomicInteger)使用了Unsafe中的compareAndSwap()方法以提供最佳性能。与Java中的标准悲观同步机制相比，该操作广泛用于无锁算法中，该算法可以利用CAS处理器指令提供极大的加速。以下为使用Unsafe的CAS操作实现的一个计数器范例：

public class CASCounter {
    private Unsafe unsafe;
    private volatile long val = 0;
    // 字段val在对象实例内存起始地址的偏移量
    private long offset;

    public static void main(String[] args) throws NoSuchFieldException, InterruptedException {
        CASCounter casCounter = new CASCounter();
        ExecutorService executorService = Executors.newFixedThreadPool(1000);
        IntStream.range(0, 1000)
                .forEach(i -> executorService.execute(casCounter::increment));
        executorService.shutdown();
        Thread.sleep(1000);
        // 输出1000
        System.out.println(casCounter.val);
    }

    private Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            return (Unsafe) f.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public CASCounter() throws NoSuchFieldException {
        unsafe = getUnsafe();
        // objectFieldOffset:获取
        offset = unsafe.objectFieldOffset(CASCounter.class.getDeclaredField("val"));
    }

    public void increment() {
        long oldVal = val;
        while (!unsafe.compareAndSwapLong(this, offset, oldVal, oldVal + 1)) {
            oldVal = val;
        }
    }

    public long getVal() {
        return val;
    }
}

Unsafe线程切换

Unsafe类中提供了park()与unpark()两个方法让JVM用来进行上下文切换线程。当线程正在等待某个操作时，JVM可以使用不安全类中的park()方法来阻塞该线程，该方法类似于Object.wait()方法，不过它调用的是本地操作系统代码，因此利用某些体系结构细节来获得最佳性能。当线程被阻塞并需要再次使其可运行时，JVM使用unpark（）方法。可以在一些线程池应用中看到这些方法调用，如ForkJoinPool、LockSupport、Exchanger等。

附代码代码

public class UnsafeTest {
    private int number;

    public UnsafeTest() {
        this.number = 1;
    }

    public static void main(String[] args) {
        offHeapTest();
    }

    public static void offHeapTest() {
        // long SUPER_SIZE = (long) Integer.MAX_VALUE * 2;
        long SUPER_SIZE = Integer.MAX_VALUE;
        OffHeapArray array = new OffHeapArray(SUPER_SIZE);
        int sum = 0;
        for (int i = 0; i < 100; i++) {
            array.set((long) Integer.MAX_VALUE + i, (byte) 1);
            long each = array.get((long) Integer.MAX_VALUE + i);
            sum += each;
        }
        System.out.println("sum:" + sum + ", array.address:" + array.address + ",array.size():" + array.size() + " ,SUPER_SIZE:" + SUPER_SIZE);
        System.out.println(ClassLayout.parseInstance(array).toPrintable());
        array.freeMemory();
    }

    public static void instanceOperate() throws InstantiationException, NoSuchFieldException {
        Unsafe unsafe = getUnsafe();
        UnsafeTest test = (UnsafeTest) unsafe.allocateInstance(UnsafeTest.class);
        // 输出0
        System.out.println(test.number);
        Field numberField = UnsafeTest.class.getDeclaredField("number");
        unsafe.putInt(test, unsafe.objectFieldOffset(numberField), 1);
        // 输出1
        System.out.println(test.number);
    }


    public static Unsafe getUnsafe() {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            return (Unsafe) f.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    static class OffHeapArray {
        private final static int BYTE = 1;
        private long size;
        // 内存起始地址
        private long address;

        /**
         * 创建内存数组
         *
         * @param size 分配的内存大小
         */
        public OffHeapArray(long size) {
            this.size = size;
            // 分配内存地址
            address = getUnsafe().allocateMemory(size * BYTE);
        }

        /**
         * 设置起始内存偏移指定下标后的位置值
         *
         * @param i     数组下标，内存偏移量
         * @param value
         */
        public void set(long i, byte value) {
            getUnsafe().putByte(address + i * BYTE, value);
        }

        /**
         * 根据数组下标idx计算在内存中的位置,然后获取数组值
         *
         * @param idx 数组下标，用于计算元素内存相对数组起始地址的偏移量
         * @return
         */
        public int get(long idx) {
            return getUnsafe().getByte(address + idx * BYTE);
        }

        public long size() {
            return size;
        }

        public void freeMemory() {
            getUnsafe().freeMemory(address);
        }
    }
}
识1DD编程
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unsafe:使用sun.misc.Unsafe的各种Java类
05-23
不安全的 由安德鲁·布兰普顿（ ） | 这是利用的工具的集合。 这个Unsafe类允许直接访问JVM中的内存，这是非常危险的，但是很有趣:)。 unsafe-helper-包含一些简单的方法，这些方法使使用sun.misc.Unsafe更容易。 unsafe-collection-在ArrayList上建模的示例列表，该列表不存储对集合内对象的引用，而是直接将元素复制到列表中。 这有一些有趣的特性 列表和包含的对象所需的总内存更少。 减少GC开销。 保证对象在内存中是固定的，这可能会提供一些良好的CPU缓存好处。 对象被复制到列表中，这种复制开销可能不值得，并且您将失去许多将要使用的引用语义。 unsafe-unroller-在运行时生成虚拟字节码以复制带有Unsafe类的对象。 unsafe-benchmark-使用对所有内容进行基准测试的代码。 unsafe-t
Java中的Unsafe类详解
一名Java语言狂热分子。
04-25 583
Unsafe类详解
Java中Unsafe类详解
wit_cx的博客
04-21 417
Java中Unsafe类详解 java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作，主要提供了以下功能： 1、通过Unsafe类可以分配内存，可以释放内存； 类中提供的3个本地方法allocateMemory、reallocateMemory、freeMemory分别用于分配内存，扩充内存和释放内存，与C语言中的3个方法对应。 2、可以定位对象某字段的内存位置，也可以修改对象的字段值，即使它是私有的； public native long alloca
Java魔法类：sun.misc.Unsafe
weixin_34335458的博客
11-08 614
Unsafe类在jdk 源码的多个类中用到，这个类的提供了一些绕开JVM的更底层功能，基于它的实现可以提高效率。但是，它是一把双刃剑：正如它的名字所预示的那样，它是Unsafe的，它所分配的内存需要手动free（不被GC回收）。Unsafe类，提供了JNI某些功能的简单替代：确保高效性的同时，使事情变得更简单。 这篇文章主要是以下文章的整理、翻译。 http://mishadoff.com/b...
Unsafe类详解
CodePanda@GPF的博客
03-20 1788
Unsafe类、CAS
简单谈一谈Java中的Unsafe类
08-27
其实Java官方不推荐使用Unsafe类，因为官方认为，这个类别人很难正确使用，非正确使用会给JVM带来致命错误...但还是要会使用，下面这篇文章就来给大家简单的谈一谈关于Java中Unsafe类的相关资料，需要的朋友可以参考下
UnsafeMe:java中Unsafe类的Protopye使用
07-17
不安全的我 使用关键但非常快的序列化对象的简单库。 使用这部进行解释。 ##Warning 这个库是一个... 原因很简单：Unsafe 类的任何错误都不会导致异常，而是会导致 VM 崩溃！ 使用风险自负。 ##许可证麻省理工学院
serialization-unsafe
06-15
序列化不安全简单快速的纯 java 对象序列化器/反序列化器。 支持的类型： 所有原始类型和包装器原始类型数组细绳用户名＃＃＃用法例如，我们有一个要序列化的类 public class TestObj { private Integer integer; ...
汪文君高并发编程实战视频资源全集
08-08
 高并发编程第三阶段14讲 Unsafe中的方法使用，一半是天使，一半是魔鬼的Unsafe.mp4  高并发编程第三阶段15讲 Unsafe背后的汇编指令，牛逼男人背后的女人_.mp4  高并发编程第三阶段16讲 CountDownLatch经典案例...
java中获取Unsafe对象的两种方法
平凡
12-10 1835
两种方法可以获取到Unsafe实例 1. 把要获取Unsafe实例的类所在jar包路径追加到默认的bootstrap路径中。 Unsafe类为一单例实现，提供静态方法getUnsafe获取Unsafe实例，当且仅当调用getUnsafe方法的类为引导类加载器所加载时才合法，否则抛出SecurityException异常。 2. 反射获取 private static Unsafe getUnsafe() { try { Field field..
java中Unsafe使用讲解
热门推荐
长河的博客
12-28 2万+
前段时间因为看JUC的源码,里面有大量关于unsafe的操作,所以就来看看了.写点笔记总结下: unsafe可以帮我们直接去操作硬件资源,当然了是借助java的jit来进行的,官方不推荐使用,因为不安全,例如你使用unsafe创建一个超级大的数组,但是这个数组jvm是不管理的,只能你自己操作,容易oom,也不利于资源的回收. 好了,下面我们来看代码, 1.获取unsafe //1.最简单...
java unsafe获取指针,Java中的指针---Unsafe应用解析
weixin_39688636的博客
03-20 420
注：本文出自"美团技术团队"微信公众号Unsafe是位于sun.misc包下的一个类，主要提供一些用于执行低级别、不安全操作的方法，如直接访问系统内存资源、自主管理内存资源等，这些方法在提升Java运行效率、增强Java语言底层资源操作能力方面起到了很大的作用。但由于Unsafe类使Java语言拥有了类似C语言指针一样操作内存空间的能力，这无疑也增加了程序发生相关指针问题的风险。在程序中过度、不正...
Unsafe类
1
07-25 999
Unsafe类的介绍 Java中基于操作系统级别的原子操作类sun.misc.Unsafe，它是Java中对大多数锁机制实现的最基础类。请注意，JDK 1.8和之前JDK版本的中sun.misc.Unsafe类可提供的方法有较大的变化，本文基于JDK 1.8。sun.misc.Unsafe类提供的原子操作基于操作系统直接对CPU进行操作，而以下这些方法又是sun.misc.Unsafe类中经常被使用的： java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作，主
Java中的Unsafe类
在路上
04-24 2710
介绍并总结了Unsafe的几类功能方法,比如并发相关,内存相关,Class相关,并举例说明
java：Unsafe
a232884c的博客
09-29 1854
底层的源码中，经常可见Unsafe，Unsafe类是java用于内存管理的类，但操作不当，可能导致内存泄漏等问题，官方亦不推荐过多使用Unsafe，故而名为Unsafe。
Java 魔法类 Unsafe 详解
xuejun_1996的博客
02-14 1139
Unsafe详解
第十章 java重要知识点（Java中Unsafe类）
Re_view的博客
01-30 376
第十章 java重要知识点（Java中Unsafe类）
C#中unsafe的使用
youandme520的专栏
06-04 4887
1. unsafe在C#程序中的使用场合： 　实时应用，采用指针来提高性能； 　引用非.net DLL提供的如C＋＋编写的外部函数，需要指针来传递该函数； 　调试，用以检测程序在运行过程中的内存使用状况。 2. 使用unsafe的利弊 　　好处是：性能和灵活性提高；可以调用其他dll的函数，提高了兼容性；可以得到内存地址； 　　麻烦是：非法修改了某些变量；内存泄漏。 3. unsafe与unmanaged的区别 　　managed code是在CLR监管下运行的程序。以下任务由CLR来执行：管
java zookeeper 使用_java 中 zookeeper简单使用
最新发布
06-02
好的，我可以为您介绍一下 Java 中 ZooKeeper 的简单使用。 首先，您需要通过 Maven 或 Gradle 将 ZooKeeper 客户端库添加到您的项目中。然后，您可以使用以下代码连接到 ZooKeeper 服务器： ```java String ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值