Java如何以及为什么使用Unsafe？

总览

sun.misc.Unsafe至少在Java 1.4（2004）中就已经存在于Java中。在Java 9中，不安全将与许多其他供内部使用的类一起隐藏。以提高JVM的可维护性。尽管仍不确定究竟将取代Unsafe到底是什么，但我怀疑将取代Unsafe不仅仅是一件事，但它提出了一个问题，为什么要使用它？

执行Java语言不允许的但仍然有用的操作。

Java不允许使用低级语言可用的许多技巧。对于大多数开发人员而言，这是一件好事，不仅可以使您免于自己，而且还可以使您从同事中免除。这也使导入开放源代码更加容易，因为您知道它们可以造成的损害是有限的。或至少可以限制您意外执行的操作。如果您尽力而为，仍然可能造成伤害。

但是您为什么还要尝试，您可能会感到奇怪？在不安全的情况下构建库时，很多（但不是全部）方法很有用，并且在某些情况下，如果不使用JNI，则没有其他方法可以做同样的事情，这更加危险，并且您将失去“一次编译，在任何地方运行”的权限。 ”

对象反序列化

使用框架反序列化或构建对象时，您要假设要重新构成以前存在的对象。您期望您将使用反射来调用类的setter，或者更可能直接设置内部字段，甚至最终字段。问题是您想创建一个对象的实例，但是您实际上并不需要构造函数，因为这可能只会使事情变得更加困难并产生副作用。

public class A implements Serializable {private final int num;public A(int num) {System.out.println("Hello Mum");this.num = num;}public int getNum() {return num;}
}

在此类中，您应该能够重建和设置final字段，但是如果您必须调用构造函数，并且它可能完成与反序列化无关的事情。由于这些原因，许多库使用Unsafe来创建实例而不调用构造函数。

Unsafe unsafe = getUnsafe();
Class aClass = A.class;
A a = (A) unsafe.allocateInstance(aClass);

不需要时，调用allocateInstance可以避免调用适当的构造函数。

线程安全访问直接内存

Unsafe的另一个用途是对堆外内存的线程安全访问。 ByteBuffer使您可以安全地访问堆外或直接内存，但是它没有任何线程安全操作。如果要在进程之间共享数据，这特别有用。

import sun.misc.Unsafe;
import sun.nio.ch.DirectBuffer;import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.reflect.Field;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;public class PingPongMapMain {public static void main(String... args) throws IOException {boolean odd;switch (args.length < 1 ? "usage" : args[0].toLowerCase()) {case "odd":odd = true;break;case "even":odd = false;break;default:System.err.println("Usage: java PingPongMain [odd|even]");return;        }int runs = 10000000;long start = 0;System.out.println("Waiting for the other odd/even");File counters = new File(System.getProperty("java.io.tmpdir"), "counters.deleteme");        counters.deleteOnExit();try (FileChannel fc = new RandomAccessFile(counters, "rw").getChannel()) {MappedByteBuffer mbb = fc.map(FileChannel.MapMode.READ_WRITE, 0, 1024);long address = ((DirectBuffer) mbb).address();for (int i = -1; i < runs; i++) {for (; ; ) {long value = UNSAFE.getLongVolatile(null, address);boolean isOdd = (value & 1) != 0;if (isOdd != odd)// wait for the other side.continue;// make the change atomic, just in case there is more than one odd/even processif (UNSAFE.compareAndSwapLong(null, address, value, value + 1))break;}if (i == 0) {System.out.println("Started");start = System.nanoTime();}}}System.out.printf("... Finished, average ping/pong took %,d ns%n",(System.nanoTime() - start) / runs);}static final Unsafe UNSAFE;static {try {Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");theUnsafe.setAccessible(true);UNSAFE = (Unsafe) theUnsafe.get(null);} catch (Exception e) {throw new AssertionError(e);}}
}

当您在两个程序中运行此程序时，一个程序带有奇数，另一个程序带有偶数。您可以看到每个进程都通过持久共享内存来更改数据。

在每个程序中，它会将相同的磁盘高速缓存映射到进程中。内存中实际上只有一个副本。这意味着可以共享内存，前提是您使用线程安全操作，例如volatile和CAS操作。

i7-3970X的输出为

等待另一个奇/偶
已开始
…完成后，平均ping / pong花费了83 ns

这是两个进程之间的83 ns往返时间。当您考虑使用System V IPC大约需要2500 ns，并且IPC易变而不是持续存在时，这很快。