JAVA Unsafe 类介绍

Unsafe 类提供了低级别、不安全的原始操作，这些操作可以直接访问内存。由于这些操作非常强大，可以直接操作内存，因此也非常危险。如果使用不当，可能会导致严重的内存泄露问题。

Unsafe 类的主要功能包括：

1. 直接内存访问：可以分配和释放内存，创建和操作对象。

  private static final int BUFFER_SIZE = 1024;
 
    // 获取Unsafe实例
    private static final Unsafe unsafe = getUnsafeInstance();
 
    // 分配内存
    private static final long buffer = unsafe.allocateMemory(BUFFER_SIZE);
 
    private static Unsafe getUnsafeInstance() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
 
    public static void main(String[] args) {
        // 使用直接内存
        unsafe.setMemory(buffer, BUFFER_SIZE, (byte) 0);
 
        // ... 进行其他操作
 
        // 释放内存
        unsafe.freeMemory(buffer);
    }

1. 线程和锁：提供了线程的挂起和恢复、定时等待等操作。

    private static final Unsafe UNSAFE;
    private static final long THREAD_PTR;
   
    static {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            UNSAFE = (Unsafe) field.get(null);
   
            Thread currentThread = Thread.currentThread();
            THREAD_PTR = UNSAFE.getLong(currentThread, UNSAFE.objectFieldOffset(Thread.class.getDeclaredField("threadStatus")));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
   
    public static void parkThread() {
        UNSAFE.park(false, 0L);
    }
   
    public static void unparkThread() {
        UNSAFE.unpark(Thread.currentThread());
    }
   
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("Thread is going to be parked");
            parkThread();
            System.out.println("Thread is unparked");
        });
   
        thread.start();
        Thread.sleep(1000); // Wait for the thread to start and print the first message
        unparkThread(); // Unpark the thread
    }

2. 可见性操作：提供了一些方法来保证线程间的可见性。

     private static final Unsafe UNSAFE;
       private static final long VALUE_OFFSET;
    
       static {
           try {
               Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
               theUnsafe.setAccessible(true);
               UNSAFE = (Unsafe) theUnsafe.get(null);
    
               VALUE_OFFSET = UNSAFE.objectFieldOffset(
                   UnsafeVisibilityExample.class.getDeclaredField("value"));
           } catch (Exception e) {
               throw new Error(e);
           }
       }
    
       private volatile int value = 0;
    
       public void increaseValue() {
           UNSAFE.putOrderedInt(this, VALUE_OFFSET, value + 1);
       }
    
       public int getValue() {
           return value;
       }
    
       public static void main(String[] args) throws InterruptedException {
           UnsafeVisibilityExample example = new UnsafeVisibilityExample();
    
           Thread t1 = new Thread(() -> {
               for (int i = 0; i < 10000; i++) {
                   example.increaseValue();
               }
           });
    
           Thread t2 = new Thread(() -> {
               while (example.getValue() < 10000) {
                   // Busy wait until condition is met
               }
           });
    
           t1.start();
           t2.start();
    
           t1.join();
           t2.join();
    
           System.out.println("Value after both threads have finished: " + example.getValue());
       }

3. CAS 操作：提供了 CompareAndSwap 等原子操作。

    private static final Unsafe UNSAFE;
    private static final long VALUE_OFFSET;
   
    static {
        try {
            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
            theUnsafe.setAccessible(true);
            UNSAFE = (Unsafe) theUnsafe.get(null);
   
            VALUE_OFFSET = UNSAFE.objectFieldOffset(UnsafeTest.class.getDeclaredField("value"));
        } catch (Exception e) {
            throw new Error(e);
        }
    }
   
    private volatile int value;
   
    public static void main(String[] args) {
        UnsafeTest unsafeTest = new UnsafeTest();
        unsafeTest.value = 10;
   
        System.out.println("Before: " + unsafeTest.value);
   
        boolean success = UNSAFE.compareAndSwapInt(unsafeTest, VALUE_OFFSET, 10, 20);
   
        System.out.println("Success: " + success);
        System.out.println("After: " + unsafeTest.value);
    }