Java 安全生成uuid java 出于安全原因

转载

laokugonggao 2024-06-23 16:08:00

文章标签 Java 安全生成uuid java 编程语言大数据设计模式 文章分类 Java 后端开发

总览

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 process
                    if (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易变而不是持续存在时，这很快。