为什么 sun.misc.Unsafe 存在，以及如何在现实世界中使用它？

Question

前几天我偶然发现了 sun.misc.Unsafe 包，并对它的功能感到惊讶。

当然，该类没有记录，但我想知道是否有充分的理由使用它。可能会出现哪些场景需要使用它？它如何在现实场景中使用？

此外，如果您确实需要它，这是否表明您的设计可能有问题？

为什么Java还要包含这个类呢？

Answer 1

示例

1. VM“内在化”。即无锁哈希表中使用的 CAS（比较和交换）
   例如：sun.misc.Unsafe.compareAndSwapInt
   它可以对包含 CAS 特殊指令的本机代码进行真正的 JNI 调用

   在此处了解有关 CAS 的更多信息 http://en.wikipedia.org/wiki/Compare-and-swap< /a>

2. 主机虚拟机的 sun.misc.Unsafe 功能可用于分配未初始化的对象，然后将构造函数调用解释为任何其他方法调用。

3. 可以从本机地址跟踪数据。可以检索
   使用 java.lang.Unsafe 类获取对象的内存地址，并通过不安全的 get/put 方法直接对其字段进行操作！

4. JVM 编译时优化。高性能VM使用“魔法”，需要低级操作。例如： http://en.wikipedia.org/wiki/Jikes_RVM

5. 分配内存，sun.misc.Unsafe .allocateMemory 例如：- 当调用 ByteBuffer.allocateDirect 时，

6. 跟踪调用堆栈并使用 sun.misc.Unsafe 实例化的值重放，对于检测很有用

7. sun.misc.Unsafe.arrayBaseOffset 和arrayIndexScale 可用于开发 arraylet，这是一种有效地将大型数组分解为较小对象的技术，以限制大型对象上扫描、更新或移动操作的实时成本

8. http://robaustin.wikidot.com/how-to-write-to-direct-memory-locations-in-java

有关参考的更多信息，请参阅此处 - http://bytescrolls.blogspot.com/2011/04/interesting-uses-of-sunmiscunsafe.html

Answer 2

仅通过运行 搜索 在一些代码搜索引擎中，我得到以下示例：

• Java 对象表示法 - 使用它来提高效率数组处理，引用javadoc

用于获取对 {@link Unsafe} 对象的访问权限的简单类。 {@link 不安全}
* 是允许对数组进行高效 CAS 操作所必需的。请注意，
{@link java.util.concurrent.atomic} 中的版本，例如 {@link
java.util.concurrent.atomic.AtomicLongArray}，需要额外的内存排序
这些算法中通常不需要的保证，也是
在大多数处理器上都很昂贵。

• SoyLatte - java 6 for osx javadoc 摘录

/** 用于静态的基于 sun.misc.Unsafe 的 FieldAccessors 的基类
字段。据观察，只有九种类型
从反射代码的角度来看字段：八个原语
类型和对象。使用类 Unsafe 而不是生成类
字节码可以节省内存和加载时间
动态生成的 FieldAccessors。 */

• 尖峰源

/*
通过线路发送的 FinalFields .. 如何在网络上解组并重新创建对象
接收方？我们不想调用构造函数，因为它会为
最后的字段。我们必须重新创建最终字段，就像发送方那样。
sun.misc.Unsafe 为我们做到了这一点。
*/

还有很多其他例子，只需点击上面的链接...

Answer 3

有趣的是，我什至从未听说过这个课程（这可能是一件好事，真的）。

我想到的一件事是使用 Unsafe#setMemory 将包含某一点敏感信息（密码、密钥等）的缓冲区归零。您甚至可以对“不可变”对象的字段执行此操作（我再次认为普通的旧反射也可以在这里发挥作用）。不过，我不是安全专家，所以对此持保留态度。

Answer 4

基于使用 eclipse 进行引用跟踪对 Java 1.6.12 库的非常简短的分析，似乎 Unsafe 的每个有用功能都以有用的方式公开。

CAS 操作通过 Atomic* 类公开。
内存操作函数通过 DirectByteBuffer 公开
同步指令（park、unpark）通过 AbstractQueuedSynchronizer 公开，而 AbstractQueuedSynchronizer 又由 Lock 实现使用。

Answer 5

Unsafe.throwException - 允许抛出已检查的异常而不声明它们。

这在某些处理反射或 AOP 的情况下很有用。

假设您为用户定义的接口构建通用代理。用户只需在接口中声明异常即可指定在特殊情况下实现抛出哪个异常。那么这是我知道的唯一方法，在接口的动态实现中引发检查异常。

import org.junit.Test;
/** need to allow forbidden references! */ import sun.misc.Unsafe;

/**
 * Demonstrate how to throw an undeclared checked exception.
 * This is a hack, because it uses the forbidden Class {@link sun.misc.Unsafe}.
 */
public class ExceptionTest {

    /**
     * A checked exception.
     */
    public static class MyException extends Exception {
        private static final long serialVersionUID = 5960664994726581924L;
    }

    /**
     * Throw the Exception.
     */
    @SuppressWarnings("restriction")
    public static void throwUndeclared() {
        getUnsafe().throwException(new MyException());
    }

    /**
     * Return an instance of {@link sun.misc.Unsafe}.
     * @return THE instance
     */
    @SuppressWarnings("restriction")
    private static Unsafe getUnsafe() {
        try {

            Field singleoneInstanceField = Unsafe.class.getDeclaredField("theUnsafe");
            singleoneInstanceField.setAccessible(true);
            return (Unsafe) singleoneInstanceField.get(null);

        } catch (IllegalArgumentException e) {
            throw createExceptionForObtainingUnsafe(e);
        } catch (SecurityException e) {
            throw createExceptionForObtainingUnsafe(e);
        } catch (NoSuchFieldException e) {
            throw createExceptionForObtainingUnsafe(e);
        } catch (IllegalAccessException e) {
            throw createExceptionForObtainingUnsafe(e);
        }
    }

    private static RuntimeException createExceptionForObtainingUnsafe(final Throwable cause) {
        return new RuntimeException("error while obtaining sun.misc.Unsafe", cause);
    }


    /**
     * scenario: test that an CheckedException {@link MyException} can be thrown
     * from an method that not declare it.
     */
    @Test(expected = MyException.class)
    public void testUnsingUnsaveToThrowCheckedException() {
        throwUndeclared();
    }
}

Answer 6

类不安全

用于执行低级、不安全操作的方法集合。尽管该类和所有方法都是公共的，但该类的使用受到限制，因为只有受信任的代码才能获取它的实例。

它的一种用途是在 java.util.concurrent.atomic 类中：

• AtomicIntegerArray
• AtomicLongArray

Answer 7

为了高效的内存复制（至少对于短块来说复制速度比 System.arraycopy() 更快）； Java LZF 和 Snappy 使用> 编解码器。他们使用“getLong”和“putLong”，这比逐字节复制要快；在复制 16/32/64 字节块等内容时特别有效。

Answer 8

我最近致力于重新实现 JVM，发现数量惊人的类是用 Unsafe 实现的。该类主要是为 Java 库实现者设计的，并且包含从根本上不安全但对于构建快速原语所必需的功能。例如，有获取和写入原始字段偏移量、使用硬件级同步、分配和释放内存等方法。它不适合普通 Java 程序员使用；它没有文档记录，特定于实现，并且本质上不安全（因此得名！）。此外，我认为 SecurityManager 在几乎所有情况下都将禁止访问它。

简而言之，它的存在主要是为了允许库实现者访问底层机器，而不必在某些类（例如 AtomicInteger 本机）中声明每个方法。您不需要在常规 Java 编程中使用或担心它，因为重点是使其余库足够快，以便您不需要这种访问。

Answer 9

堆外收集对于分配大量内存并在使用后立即释放内存而不产生 GC 干扰可能很有用。我编写了一个 库，用于基于 sun.misc 处理堆外数组/列表.不安全。

Answer 10

使用它可以有效地访问和分配大量内存，例如在您自己的体素引擎中！ （即 Minecraft 风格的游戏。）

根据我的经验，JVM 通常无法在您真正需要的地方消除边界检查。例如，如果您正在迭代一个大型数组，但实际的内存访问隐藏在循环中的非 virtual* 方法调用下方，则 JVM 仍可能对每个数组访问执行边界检查，而不是在之前执行一次循环。因此，为了获得潜在的巨大性能提升，您可以通过使用 sun.misc.Unsafe 直接访问内存的方法来消除循环内的 JVM 边界检查，确保在正确的位置自行执行任何边界检查。 （您要在某种程度上进行边界检查，对吧？）
_{*通过非虚拟，我的意思是 JVM 不必动态解析您的特定方法是什么，因为您已经正确保证类/方法/实例是 static/final/what-have- 的某种组合 对于我自己}

开发的体素引擎，这在块生成和序列化期间（在我一次读取/写入整个数组的地方）带来了显着的性能提升。结果可能会有所不同，但如果您的问题是缺乏边界消除，那么这将解决它。

这存在一些潜在的主要问题：具体来说，当您向接口的客户端提供无需边界检查即可访问内存的能力时，他们可能会滥用它。 （不要忘记，黑客也可以是您界面的客户端......尤其是在用 Java 编写的体素引擎的情况下。）因此，您应该以一种不会滥用内存访问的方式设计界面，或者您应该非常小心地验证用户数据，以免其永远与您的危险界面混合。考虑到黑客可能通过未经检查的内存访问造成灾难性的后果，因此最好同时采用这两种方法。

Answer 11

我们使用 Unsafe 实现了像 Arrays、HashMaps、TreeMaps 这样的巨大集合。
为了避免/最小化碎片，我们使用 dlmalloc 不安全。
这帮助我们获得了并发性能。

Answer 12

Unsafe.park() 和 Unsafe.unpark() 用于构建自定义并发控制结构和协作调度机制。

Answer 13

我自己没有使用过它，但我想如果你有一个变量只是偶尔被多个线程读取（所以你真的不想让它变得易失）你可以使用 putObjectVolatile 在主线程中写入它时，以及从其他线程进行罕见读取时。

Answer 14

如果您需要替换当前使用它的类之一提供的功能，则需要它。

这可以是自定义/更快/更紧凑的序列化/反序列化、更快/更大的缓冲区/可调整大小的 ByteBuffer 版本，或者添加原子变量（例如当前不支持的变量）。

我曾经用过它来完成所有这些工作。

Answer 15

其使用的一个示例是 random 方法，该方法 调用 unsafe 来更改种子。

该网站也有一些它的用途。

Answer 16

该对象似乎可以在比 Java 代码通常允许的级别更低的级别上工作。如果您正在编写高级应用程序，那么 JVM 会将内存处理和其他操作从代码级别中抽象出来，以便更容易编程。通过使用 Unsafe 库，您可以有效地完成通常会为您完成的低级操作。

正如 woliveirajr 所说，“random()”使用 Unsafe 来播种，就像许多其他操作将使用 Unsafe 中包含的 allocateMemory() 函数一样。

作为一名程序员，您可能永远不需要这个库，但对低级元素的严格控制确实会派上用场（这就是为什么在主要产品中仍然存在汇编和（在较小程度上）C 代码）