多线程 - Unsafe

痛定思痛。 2023-10-09 23:17 11阅读 0赞

## 是什么 ##

Java的sun.misc.Unsafe类提供了直接访问底层内存和执行不安全操作的功能。  
它是一个非常强大的工具，但使用它需要非常谨慎，因为它可以绕过Java的内存管理和访问控制机制。

使用Unsafe类可以进行以下操作：

直接操作内存：Unsafe类提供了许多可以直接操作内存的方法，例如读写基本数据类型、复制内存块、分配和释放内存等。
    绕过访问控制：通过Unsafe类，可以访问和修改Java对象的私有字段、调用私有方法等，这些操作通常是受到Java语言本身的访问控制机制限制的。
    执行CAS操作：CAS（Compare-and-Swap）是一种无锁算法，可以在并发环境下实现高效的数据同步。Unsafe类提供了一些CAS操作的方法，例如compareAndSwapInt、compareAndSwapLong等。

由于Unsafe类可以绕过Java的内存管理和访问控制机制，因此在使用时需要非常谨慎。  
如果使用不当，可能会导致内存泄漏、线程安全问题、JVM崩溃等问题。  
因此，通常情况下，应该尽量避免直接使用Unsafe类，而是使用更高级别的API来完成需要的操作。

## 使用反射获取Unsafe类 ##

import java.lang.reflect.Field;
    import sun.misc.Unsafe;
    
    /**
     * Java的sun.misc.Unsafe类通常是作为JDK内部使用的工具类，不是公共API的一部分，
     * 因此没有提供公共构造函数或静态工厂方法来获取它的实例。但是，可以通过反射来获取Unsafe类的实例。
     *
     *
     * 首先使用反射获取Unsafe类的theUnsafe静态字段，然后设置访问权限，最后使用get()方法获取Unsafe实例。
     * 需要注意的是，由于theUnsafe字段是私有的，因此需要使用setAccessible(true)方法来打开访问权限。
     *
     * 需要注意的是，由于Unsafe类是JDK内部使用的类，因此在不同的JDK版本中可能存在差异。
     * 使用反射获取Unsafe实例可能不是一种稳定的做法，可能会受到未来版本的限制或不兼容性问题。
     * 因此，应该尽量避免直接使用Unsafe类，并使用更高级别的API来完成需要的操作。
     */
    public class MyUnsafeDemo {
        
        public static void main(String[] args) throws Exception {
        
            // -> private static final Unsafe theUnsafe;
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            // 开启theUnsafe字段的访问权限
            field.setAccessible(true);
            // field.get(null)表示获取Unsafe类的theUnsafe静态字段的值。
            // 由于该字段是静态的，不需要指定对象实例，因此将其设为null。
            // 如果成员变量是实例变量，那么需要传递一个对象实例作为参数，例如field.get(obj)表示获取obj对象上该成员变量的值。
            Unsafe unsafe = (Unsafe) field.get(null);
            System.out.println("Got unsafe instance: " + unsafe);
        }
    }

## 使用Unsafe类中的compareAndSwapInt方法进行CAS操作 ##

import sun.misc.Unsafe;
    
    /**
     *
     * CAS（Compare-and-Swap）是一种无锁算法，用于在并发环境下实现高效的数据同步。
     * CAS操作通常包含三个参数：需要更新的内存地址、期望的值、新值。
     * 如果当前内存地址上的值等于期望的值，就将其更新为新值，否则不更新。
     *
     * 在Java的sun.misc.Unsafe类中，提供了一些用于CAS操作的方法，例如compareAndSwapInt、compareAndSwapLong、compareAndSwapObject等。
     * 这些方法通常需要传入需要更新的对象、偏移量、期望值和新值四个参数。
     *
     *
     * 首先使用Unsafe类的getUnsafe()静态方法获取Unsafe实例，
     * 然后使用objectFieldOffset()方法获取value字段的偏移量。
     * compareAndSet()方法使用compareAndSwapInt()方法实现CAS操作。
     * 在该方法中，this表示要更新的对象，valueOffset表示字段偏移量，expected表示期望的值，update表示新值。
     * 如果当前对象的value字段等于期望的值expected，则将其更新为新值update。
     *
     * 需要注意的是，CAS操作可能存在ABA问题，即一个值被其他线程修改为某个值，然后又被修改为原来的值。
     * 为了解决这个问题，可以使用版本号等技术来避免ABA问题。
     * 另外，由于CAS操作需要多次尝试才能成功，因此在高并发场景下，可能会出现自旋等待的情况，从而降低了性能。
     * 因此，需要根据实际情况选择合适的同步方式。
     */
    public class MyCASDemo {
        
        private static final Unsafe UNSAFE = Unsafe.getUnsafe();
        private static final long VALUE_OFFSET;
    
        private volatile int value;
    
        static {
        
            try {
        
                VALUE_OFFSET = UNSAFE.objectFieldOffset(MyCASDemo.class.getDeclaredField("value"));
            } catch (Exception ex) {
        
                throw new Error(ex);
            }
        }
    
        public boolean compareAndSet(int expected, int update) {
        
            return UNSAFE.compareAndSwapInt(this, VALUE_OFFSET, expected, update);
        }
    
        /**
         * 首先定义了线程数和循环次数，然后创建了一个MyCASDemo对象和对应数量的线程数组。
         *  每个线程会执行一个自增的操作，即在循环中使用CAS操作将value字段自增1。如果操作失败，即当前值不等于期望值，则继续循环直到操作成功。
         *  最后输出MyCASDemo对象的value字段值，即所有线程执行完毕后的最终结果。
         *
         * 注意，在运行该代码时需要添加JVM参数“-Xbootclasspath/a:${
        JAVA_HOME}/lib/rt.jar”，否则会抛出SecurityException异常。
         * 这是因为Unsafe类只能由Bootstrap类加载器加载，而系统默认的类加载器无法加载该类。
         * @param args
         * @throws InterruptedException
         */
        public static void main(String[] args) throws InterruptedException {
        
            final int THREAD_COUNT = 10;
            final int LOOP_COUNT = 10000;
    
            MyCASDemo casDemo = new MyCASDemo();
            Thread[] threads = new Thread[THREAD_COUNT];
    
            for (int i = 0; i < THREAD_COUNT; i++) {
        
                threads[i] = new Thread(() -> {
        
                    for (int j = 0; j < LOOP_COUNT; j++) {
        
                        int oldValue, newValue;
                        do {
        
                            oldValue = casDemo.value;
                            newValue = oldValue + 1;
                        } while (!casDemo.compareAndSet(oldValue, newValue));
                    }
                });
                threads[i].start();
            }
    
            for (Thread thread : threads) {
        
                thread.join();
            }
    
            System.out.println("Final value: " + casDemo.value);
        }
    }

## 原子操作的方法 ##

包括以下几个方面：

### CAS操作 ###

CAS（Compare-and-Swap）是一种无锁算法，用于在并发环境下实现高效的数据同步。Unsafe类提供了几个CAS操作的方法，包括compareAndSwapInt、compareAndSwapLong、compareAndSwapObject等。这些方法需要传入需要更新的对象、偏移量、期望值和新值四个参数。如果当前内存地址上的值等于期望的值，则将其更新为新值，否则不更新。

### 原子整型操作 ###

Unsafe类提供了几个原子整型操作的方法，包括getAndAddInt、getAndSetInt、getAndIncrement等。这些方法可以保证在并发情况下对整型数据的读写操作具有原子性。

### 原子长整型操作 ###

Unsafe类提供了几个原子长整型操作的方法，包括getAndAddLong、getAndSetLong、getAndIncrement等。这些方法可以保证在并发情况下对长整型数据的读写操作具有原子性。

### 原子对象操作 ###

Unsafe类提供了几个原子对象操作的方法，包括compareAndSwapObject、getAndSetObject、getAndVolatileObject等。这些方法可以保证在并发情况下对对象的读写操作具有原子性。

需要注意的是，使用Unsafe类进行原子操作需要注意线程安全性和可见性问题。在高并发场景下，由于CAS操作需要多次尝试才能成功，因此可能会出现自旋等待的情况，从而降低了性能。因此，需要根据实际情况选择合适的同步方式。

## 一些线程调度相关的方法 ##

park(boolean isAbsolute, long time): 阻塞当前线程，并将其放入等待队列中。如果isAbsolute为true，则time表示绝对时间；否则表示相对时间（单位为纳秒）。
    
    unpark(Thread thread): 唤醒指定线程。
    
    monitorEnter(Object obj): 尝试获取对象的监视器，如果获取失败，则将当前线程放入对象的等待队列中。
    
    monitorExit(Object obj): 释放对象的监视器，唤醒等待队列中的线程。

这些方法在实现一些高级的同步和调度算法时非常有用。例如，park和unpark可以用来实现自旋锁、读写锁等算法，monitorEnter和monitorExit可以用来实现管程等算法。

需要注意的是，这些方法一般不建议直接使用，因为它们会绕过JVM的线程调度器和内存模型，容易出现不可预期的问题。建议在必要的情况下，使用java.util.concurrent包中提供的高级并发工具，例如Lock、Semaphore、CountDownLatch等。

## park 和 unpark ##

park和unpark是线程阻塞和解除阻塞的操作，通常和LockSupport类一起使用。

import java.util.concurrent.locks.LockSupport;
    
    /**
     *
     * 有两个线程，thread1和thread2，它们交替输出数字和字母。
     *
     * 在thread1中，使用了LockSupport.unpark(thread2)方法先唤醒了thread2线程，然后使用LockSupport.park()方法阻塞自己。
     * 当thread2线程执行完后，会使用LockSupport.unpark(thread1)方法唤醒thread1线程，thread1线程被唤醒后再执行输出操作，然后继续阻塞自己，以此循环。
     *
     * 在thread2中，先使用LockSupport.park()方法阻塞自己，等待thread1线程的唤醒。
     * 当被唤醒后，执行输出操作，然后使用LockSupport.unpark(thread1)方法唤醒thread1线程，以此循环。
     *
     * 使用park和unpark方法实现线程协作的好处在于，可以精确控制线程的阻塞和唤醒操作，
     * 从而避免了使用Object.wait和Object.notify方法时可能出现的死锁和饿死等问题。
     *
     */
    public class MyParkUnparkDemo {
        
        private static Thread thread1;
        private static Thread thread2;
    
        public static void main(String[] args) {
        
            thread1 = new Thread(() -> {
        
                for (int i = 1; i <= 10; i++) {
        
                    System.out.println("Thread1: " + i);
                    LockSupport.unpark(thread2); // 先唤醒thread2线程
                    LockSupport.park(); // 然后自己阻塞
                }
            });
    
            thread2 = new Thread(() -> {
        
                for (int i = 65; i <= 74; i++) {
        
                    LockSupport.park(); // 先阻塞自己
                    System.out.println("Thread2: " + (char) i);
                    LockSupport.unpark(thread1); // 然后唤醒thread1线程
                }
            });
    
            thread1.start();
            thread2.start();
        }
    }

## 使用Unsafe实现锁 ##

import sun.misc.Unsafe;
    
    import java.lang.reflect.Field;
    
    /**
     * 通过Unsafe实现一个简单的锁
     * 
     * 使用了一个volatile类型的int变量state表示锁的状态，0表示锁空闲，1表示锁被占用。
     * 在lock()方法中，我们使用了CAS操作实现了锁的获取，如果state为0，则将其设置为1，表示锁被当前线程占用，否则继续自旋等待。
     * 在unlock()方法中，我们将state设置为0，表示当前线程释放了锁。
     *
     * 需要注意的是，这个锁实现并不完善，存在一些问题，例如不能处理可重入锁、不支持公平性等，只是作为一个简单的示例展示了如何使用Unsafe实现一个简单的锁。
     * 在实际应用中，应该使用Java提供的线程安全类或者第三方的高性能并发库来实现线程同步。
     */
    public class MyLock {
        
    
        private volatile int state = 0;
        private static final long stateOffset;
        private static final Unsafe unsafe;
    
        static {
        
            try {
        
                // 通过反射获取Unsafe实例
                Field f = Unsafe.class.getDeclaredField("theUnsafe");
                f.setAccessible(true);
                unsafe = (Unsafe) f.get(null);
                // 获取state变量在MyLock对象中的偏移量
                stateOffset = unsafe.objectFieldOffset(MyLock.class.getDeclaredField("state"));
            } catch (Exception ex) {
        
                throw new Error(ex);
            }
        }
    
        public void lock() {
        
            // 自旋
            while (true) {
        
                int oldState = state;
                if (oldState == 0 && unsafe.compareAndSwapInt(this, stateOffset, 0, 1)) {
        
                    // 修改成功，获取锁
                    return;
                }
                // 修改失败，继续自旋
            }
        }
    
        public void unlock() {
        
            state = 0;
        }
    
    }

## Unsafe中保证变量的可见性 ##

import sun.misc.Unsafe;
    
    /**
     *
     * 变量的可见性是指一个线程修改了一个共享变量的值，其他线程能够立即看到这个修改的结果。
     * 通常情况下，共享变量被存储在主内存中，每个线程都有自己的工作内存，线程对共享变量的操作都是在自己的工作内存中进行的。
     * 当一个线程修改了共享变量的值后，如果不加特殊处理，其他线程可能无法立即看到这个修改的结果。
     *
     * Unsafe类提供了一些方法来保证变量的可见性，其中最常用的方法是volatile读和写操作。
     *
     * 使用Unsafe类的putIntVolatile()和getIntVolatile()方法来设置和读取volatile变量value的值，这样可以保证任何修改value的线程对其他线程可见。
     * 在实际开发中，可以使用volatile关键字来保证变量的可见性，不必直接使用Unsafe类的方法。
     */
    public class MyVolatileDemo {
        
        private static final Unsafe UNSAFE = Unsafe.getUnsafe();
        private static final long VALUE_OFFSET;
    
        private volatile int value;
    
        static {
        
            try {
        
                VALUE_OFFSET = UNSAFE.objectFieldOffset(MyVolatileDemo.class.getDeclaredField("value"));
            } catch (Exception ex) {
        
                throw new Error(ex);
            }
        }
    
        public void setValue(int newValue) {
        
            UNSAFE.putIntVolatile(this, VALUE_OFFSET, newValue);
        }
    
        public int getValue() {
        
            return UNSAFE.getIntVolatile(this, VALUE_OFFSET);
        }
    }

## Unsafe类提供的与Class对象相关的方法 ##

Unsafe类提供了多个与Class对象相关的方法，包括：

defineClass(String name, byte[] b, int off, int len, ClassLoader loader, ProtectionDomain protectionDomain)：将字节数组转换为Class对象并返回。其中，name是类的全限定名，b是字节数组，off和len指定字节数组中类的起始位置和长度，loader是用于加载该类的类加载器，protectionDomain是用于保护该类的安全域。
    allocateInstance(Class<?> cls)：分配一个未初始化的对象并返回。这个对象的所有字节都被设置为零，所以它的状态不是未定义的，而是不安全的。需要使用构造函数来初始化该对象。
    staticFieldOffset(Field field)：获取静态字段在类中的偏移量。
    staticFieldBase(Field field)：获取静态字段所在的类对象。
    objectFieldOffset(Field field)：获取非静态字段在类中的偏移量。
    getInt(Object obj, long offset)：获取指定偏移量处的int类型的字段值。
    putInt(Object obj, long offset, int value)：设置指定偏移量处的int类型的字段值。
    getObject(Object obj, long offset)：获取指定偏移量处的Object类型的字段值。
    putObject(Object obj, long offset, Object value)：设置指定偏移量处的Object类型的字段值。

使用这些方法需要注意，由于Unsafe类的方法可以直接访问内存，因此可能会导致安全问题，需要谨慎使用。

## 静态变量的获取 ##

import sun.misc.Unsafe;
    
    import java.lang.reflect.Field;
    
    /**
     *
     * 首先获取了 Unsafe 的实例，然后使用 staticFieldOffset 方法获取了静态字段 counter 在内存中的偏移量 offset，
     * 并使用 staticFieldBase 方法获取了静态字段 counter 所在的对象 base。接下来，我们使用 getInt 方法获取了静态字段 counter 的值，并打印出来。
     * 然后，我们使用 getAndAddInt 方法将静态字段 counter 的值加 1，并再次使用 getInt 方法获取静态字段 counter 的值，并打印出来。
     *
     */
    public class MyUnsafeClassExample {
        
    
        private static int counter = 0;
    
        public static void main(String[] args) throws Exception {
        
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            Unsafe unsafe = (Unsafe) field.get(null);
    
            long offset = unsafe.staticFieldOffset(MyUnsafeClassExample.class.getDeclaredField("counter"));
            Object base = unsafe.staticFieldBase(MyUnsafeClassExample.class.getDeclaredField("counter"));
    
            // Print initial value of counter
            System.out.println("Initial value of counter: " + unsafe.getInt(base, offset));
    
            // Update the value of counter
            unsafe.getAndAddInt(base, offset, 1);
    
            // Print updated value of counter
            System.out.println("Updated value of counter: " + unsafe.getInt(base, offset));
        }
    }

## 类的初始化 ##

package com.lfsun.highconcurrency000.unsafe;
    
    import sun.misc.Unsafe;
    
    /**
     *
     * Unsafe类提供了一些方法用于类的初始化，包括shouldBeInitialized和ensureClassInitialized。
     *
     * shouldBeInitialized方法用于检查一个类是否已经被初始化。它接受一个Class对象作为参数，并返回一个布尔值。
     * 如果该类已经被初始化，返回true，否则返回false。
     * 这个方法的实现是基于类的初始化状态标记来实现的，如果标记为已初始化，则返回true。
     *
     * 可以看到，在调用shouldBeInitialized方法时，返回值为false，表示MyClass类还没有被初始化。
     * 在创建MyClass对象之后，类被初始化并输出相应的信息。
     *
     * ensureClassInitialized方法用于确保一个类被初始化。
     * 它接受一个Class对象作为参数，并且会强制初始化该类。
     * 这个方法可以用来确保在需要时初始化一个类，例如在并发环境中使用单例模式时可以用到。
     * 如果该类已经被初始化，这个方法不会做任何事情。
     *
     */
    public class MyClass {
        
        static {
        
            System.out.println("MyClass is initialized");
        }
        public static void main(String[] args) {
        
            Unsafe unsafe = Unsafe.getUnsafe();
            Class<?> clazz = MyClass.class;
            boolean initialized = unsafe.shouldBeInitialized(clazz);
            System.out.println("MyClass is initialized? " + initialized);
            MyClass obj = new MyClass();
    
            //unsafe.ensureClassInitialized(clazz);
        }
    }

## 其他方法 ##

// 用于获取对象成员属性在内存地址相对于此对象的内存地址的偏移量。它的作用是为了支持Java中的unsafe操作，可以通过这个偏移量来直接访问和修改对象的成员属性，而不需要使用getter和setter方法。
    public native long objectFieldOffset(Field f);
    // 用于获取给定对象的指定地址偏移量的值。这个方法可以用来直接访问Java对象的内部属性，从而支持Java中的unsafe操作。
    public native Object getObject(Object o, long offset);
    // 用于给定对象的指定地址偏移量设值。这个方法可以用来直接修改Java对象的内部属性，从而支持Java中的unsafe操作。
    public native void putObject(Object o, long offset, Object x);
    // 用于以原子方式获取指定对象的给定偏移量处的对象引用。在 Java 中，volatile 关键字用于表示变量的值可能被多个线程修改。getObjectVolatile 方法提供了对指定内存地址偏移量处对象引用的原子访问，这意味着使用此方法访问同一对象的任何线程都将看到最新的值。
    
    这种方法通常用于多线程应用程序中，其中多个线程需要访问或修改相同的共享对象。如果没有适当的同步机制（例如使用 volatile 或其他锁定构造），则多线程代码的行为可能是不可预测的，可能会导致竞争条件、死锁或其他并发相关问题。
    	public native Object getObjectVolatile(Object o, long offset);
    	// 用于以原子方式设置指定对象的给定偏移量处的对象引用。在 Java 中，volatile 关键字用于表示变量的值可能被多个线程修改。使用 putObjectVolatile 方法来设置对象在指定偏移量处的值将保证原子性，这意味着任何访问相同对象的线程都会看到最新的值。
    	public native void putObjectVolatile(Object o, long offset, Object x);
    	// 用于将给定对象的指定地址偏移量处的对象引用设置为指定的值。这个方法是 putObjectVolatile() 方法的一种变体，它提供了更轻量级的原子性保证。与 putObjectVolatile() 方法不同，putOrderedObject() 方法无法确保改变的值立即对其他线程可见，只有在使用了 volatile 关键字修饰属性时才能生效。
    	public native void putOrderedObject(Object o, long offset, Object x);
    	// 它可以绕过构造函数和初始化代码来直接创建一个对象实例。这个方法与使用 new 关键字来创建对象实例不同，因为它不会调用任何构造函数或初始化代码。
    	public native Object allocateInstance(Class<?> cls) throws InstantiationException;
    	// 用于获取指定数组类中每个元素的大小。在 Java 中，不同类型的数组中每个元素的大小不同，例如，byte 类型的数组中每个元素占据 1 个字节，而 int 类型的数组中每个元素占据 4 个字节。
    	
    该方法可以返回给定数组类型的元素大小（即偏移缩放因子），以便在进行数组操作时，可以通过偏移量和缩放因子来计算正确的内存地址。
    
    public native int arrayIndexScale(Class<?> arrayClass);
    // 用于插入一个加载屏障（Load Barrier）。在多线程编程中，为了保证数据的正确性和可见性，可能需要使用到内存屏障。
    
    内存屏障是一种硬件或软件机制，它可以强制处理器或线程执行一些特定的内存操作顺序。在 Java 中，内存屏障分为读屏障、写屏障和全屏障。加载屏障是一种读屏障，它会强制缓存系统从主存中重新加载数据，并且在加载数据之前防止指令重排，以确保读取到最新的数据。因此，使用 loadFence() 可以保证在此方法调用之前所做的读取操作都已经完成。
    public native void loadFence();
    // 它提供了一个内存屏障，确保在执行任何后续存储或加载操作之前，所有先前的存储操作都已完成。该方法的目的是防止编译器或处理器对存储进行重新排序，这可能导致多线程程序中出现意外行为。
    
    通常情况下，当多个线程访问共享数据时，会使用 storeFence() 等内存屏障来确保由一个线程对共享变量所做的更改对所有其他线程可见，并以可预测和一致的方式进行。
    
    需要注意的是，由于 storeFence() 是一种本地方法，其实现可能因平台和底层硬件体系结构而异。
    public native void storeFence();
    // 用于插入一个全屏障（Full Barrier）。在多线程编程中，为了保证数据的正确性和可见性，可能需要使用到内存屏障。
    
    内存屏障是一种硬件或软件机制，它可以强制处理器或线程执行一些特定的内存操作顺序。在 Java 中，内存屏障分为读屏障、写屏障和全屏障。全屏障是一种最严格的屏障，它会防止指令重排和缓存系统的任何优化，以确保所有之前的内存操作都已经完成。因此，使用 fullFence() 可以保证在此方法调用之前的所有内存操作都已经完成。
    public native void fullFence();