【Java多线程】JUC之魔法类(Unsafe)解析

╰半橙微兮° 2022-12-12 02:10 263阅读 0赞

# 一半是天使，一半是恶魔 #

![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16]

**Unsafe是在`sun.misc`包下的类，`不属于Java标准`，提供了一些相对`底层方法`来操作`系统底层资源`。很多Java的基础类库，包括一些被广泛使用的高性能开发库都是基于Unsafe类开发的，比如`Netty、Cassandra、Hadoop、Kafka` 等。Unsafe类在提升Java运行效率，增强Java语言底层操作能力方面起了很大的作用。**

--------------------

**为什么说它一半是天使一半是魔鬼呢？要回答这个问题，我们还是要从其特性来解释。**

Unsafe类使Java拥有了像C语言的指针一样`操作内存空间的能力`，一旦能够**直接操作内存**，这也就意味着

1.  **不受JVM管理**，也就意味着无法被GC，需要我们`手动GC`，稍有不慎就会出现`内存泄漏` ，严重时甚至可能引起JVM崩溃。
2.  Unsafe的不少方法中必须提供`原始地址(内存地址)和被替换对象的地址`，偏移量要自己计算，一旦出现问题就是`JVM崩溃级别的异常`，会导致整个JVM实例崩溃。
3.  直接操作内存，也意味着其速度更快，在高并发的条件之下能够很好地提高效率。
4.  `由于它实现的功能过于底层，因此Java官方并不建议使用的，官方文档也几乎没有。`

--------------------

# 一.获取Unsafe实例 #

*  Unsafe类是`"final"`的，不允许继承。且构造函数是`private`的，因此我们`无法在外部对Unsafe进行实例化`。
    
        // 类被final修饰，表示不能被继承
        public final class Unsafe { 
        
        	// 构造器被私有化
            private Unsafe() { }
        
            private static final Unsafe theUnsafe = new Unsafe();
        
            public static Unsafe getUnsafe() { 
                Class<?> caller = Reflection.getCallerClass();
        	        if (!VM.isSystemDomainLoader(caller.getClassLoader()))
                    throw new SecurityException("Unsafe");
                return theUnsafe;
            }
        }
 *  Unsafe类使用了**单例模式**，需要通过一个 **静态方法getUnsafe()** 来获取。但Unsafe类做了限制，如果是`普通的调用`的话，它会抛出一个`SecurityException异常` 。如下示例：
    
        public class Demo { 
            public static void main(String[] args) { 
                Unsafe unsafe = Unsafe.getUnsafe();
            }
        }
 *  运行main()方法，控制台出现如下异常：
    
        Exception in thread "main" java.lang.SecurityException: Unsafe
            at sun.misc.Unsafe.getUnsafe(Unsafe.java:90)
            at com.tiantang.study.Demo.main(Demo.java:14)
 *  **为什么会出现`SecurityException`异常呢？**
    
     *  这是因为在Unsafe类的`getUnsafe()`方法中，它做了一层校验，判断`当前类（Demo）的类加载器（ClassLoader）是不是启动类加载器（Bootstrap ClassLoader）`，如果不是，则会抛出`SecurityException异常`。**在JVM的类加载机制中，自定义的类使用的类加载器是`应用程序类加载器（Application ClassLoader）`，所以这个时候校验失败，会抛出异常。**
 *  那么如何才能获取到Unsafe类的实例呢？有`2种方案`。
    
     *  **第1种方案**：将我们自定义的类（如Demo类）所在的Jar包所在的路径通过`-Xbootclasspath`参数添加到Java命令中，当程序启动时，`Bootstrap ClassLoader会加载Demo类`，这样校验就通过了。显然这种方式**比较麻烦，而且不太实用**，因为在项目中，可能需要在`很多地方都使用Unsafe类`，如果通过Java命令行这种方式去指定，就会`很麻烦，而且容易出现纰漏。`
    
        #-Xbootclasspath/a 把调用Unsafe相关方法的类A所在jar包路径追加到默认的bootstrap路径中，使得A被引导类加载器加载，从而通过Unsafe.getUnsafe方法安全的获取Unsafe实例。
        java -Xbootclasspath/a: ${path}  # 其中path为调用Unsafe相关方法的类所在jar包路径
    
     *  **第2种方案**：通过`反射`获取单例对象theUnsafe。
    
        public Unsafe getUnsafe() throws IllegalAccessException { 
        	//Field unsafeField = Unsafe.class.getDeclaredField("theUnsafe");//也可以这样,作用相同
            Field unsafeField = Unsafe.class.getDeclaredFields()[0];
            // 将字段的访问权限设置为true
            unsafeField.setAccessible(true);
            //因为theUnsafe字段在Unsafe类中是一个静态字段，所以通过Field.get()获取字段值时，可以传null获取
            Unsafe unsafe = (Unsafe) unsafeField.get(null);
            return unsafe;
        }

# 二.Unsafe功能介绍以及实际应用 #

**Unsafe的功能如下图：**  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 1]

## 0.什么是native方法? ##

**在java中，这类方法被称为`本地方法`（Native Method），简单的说就是`由Java调用非Java代码的接口，被调用的方法是由非java 语言实现的`。**

*  **native方法**是通过`JNI（Java Native Interface）规范`实现调用的，从`Java1.1`开始 JNI 标准就是java平台的一部分，它**允许Java代码和其他语言的代码进行交互。**
 *  它可以`由C或C++语言来实现`，并编译成`DLL(windows)、SO(linux)(动态链接库)`，然后直接供java进行调用。

![在这里插入图片描述][8a9cf40ebac14955b0010f7c1eb7cc00.png]

*  具体了解JNI可以看我这篇文章[【Java基础】JNI机制开发指南—认识JNI原理及如何用 Java 调用 C 的动态链接库][Java_JNI_JNI_ Java _ C]

## 1.对象相关操作 ##

*  Unsafe类中提供了很多操作对象实例的方法。这些方法基本都是`成对出现`的，例如`getObject()和putObject()`，一个是从内存中获取给定对象的指定偏移量的Object类型对象，一个是向内存中写。与此类似的还有getInt()、getLong()…等方法。
 *  还有一组加了`volatile语义`的方法，例如：`getObjectValotile()、putObjectVolatile()`，它们的作用就是`使用volatile语义获取值和存储值`。
    
     *  **什么是volatile语义呢？** 就是读数据时每次都从主内存中取最新的值，而不是使用线程工作内存中的值；存数据时将值立马刷新到主内存，而不是先写到工作内存，等以后再刷新回主内存。

### 1.1.普通读写 ###

> **通过Unsafe可以读写一个类的属性，`即使这个属性是私有的，也可以对这个属性进行读写`。**

**读写一个Object属性的相关方法**

public native Object getObject(Object o, long offset);
    
    public native void putObject(Object o, long offset, Object x);

*  getObject()：从对象o的指定地址偏移量offset处获取变量的引用，与此类似方法有：getInt，getLong等等
 *  putObject()：对对象o的指定地址偏移量offset处设值，与此类似方法有：putInt，putLong等等
 *  **其他的`原始数据类型`也有对应的方法。**

**Unsafe还可以直接在一个地址上读写**

public native byte getByte(long var1);
    
    public native void putByte(long var1, byte var3);

*  getByte()：用于从指定内存地址处开始读取一个byte。
 *  putByte()：用于从指定内存地址写入一个byte。
 *  **其他的`原始数据类型`也有对应的方法。**

**测试: 对一个对象的属性进行读写：**

@Test
        public void fieldTest() throws NoSuchFieldException { 
            Unsafe unsafe = getUnsafe();
    
            User user = new User();
            //获取对象中字段的age字段内存地址（这个地址不是内存中的绝对地址而是一个相对地址），通过这个偏移地址对Integer的属性值进行了读写操作
            long fieldOffset = unsafe.objectFieldOffset(User.class.getDeclaredField("age"));
            System.out.println("offset:" + fieldOffset);
    
            //设置改内存地址的值为20,Integer为int的包装类型,因此需要使用putObject、getObject来写入和读取字段值
            unsafe.putObject(user, fieldOffset, 20);
    
            //获取该内存地址的值
            System.out.println("age:" + unsafe.getObject(user, fieldOffset));
            System.out.println("age:" + user.getAge());
        }
        
    	//操作对象
        @Data
        @AllArgsConstructor
        @NoArgsConstructor
       public class User { 
            private Integer age;
       }

![在这里插入图片描述][5615af8cd0a24182a292eac2c20e2d85.png]

### 1.2.volatile读写 ###

**普通的读写无法保证可见性和有序性，而volatile读写就可以保证可见性和有序性。**

public native Object getObjectVolatile(Object o, long offset);
    
    public native void putObjectVolatile(Object o, long offset, Object x);

*  getObjectVolatile()：从对象o的指定地址偏移量offset处获取变量的引用，使用volatile语义读取,与此类似方法有：getIntVolatile，getLongVolatile等等
 *  putObjectVolatile()：对对象o的指定地址偏移量offset处设值，使用volatile语义存储，与此类似方法有：putIntVolatile，putLongVolatile等等

**volatile读写相对普通读写是更加昂贵的，因为需要`保证可见性和有序性`，而与volatile写入相比`putOrderedXX写入`代价相对较低，`putOrderedXX写入不保证可见性，但是保证有序性`，所谓有序性，就是保证指令不会重排序。**

### 1.3.有序写入 ###

**有序写入只保证写入的有序性，不保证可见性，就是说一个线程的写入不保证其他线程立马可见。**

public native void putOrderedObject(Object var1, long var2, Object var4);
    
    public native void putOrderedInt(Object var1, long var2, int var4);
    
    public native void putOrderedLong(Object var1, long var2, long var4);

## 2.偏移量相关(内存地址) ##

我们可以使用Unsafe获取`对象的指针`，通过`对指针进行偏移`，我们不仅可以`直接修改指针指向的数据（即使它们是私有的），甚至可以找到JVM已经认定为垃圾、可以进行回收的对象。`

*  如：**arrayBaseOffset（获取数组第一个元素的内存地址）**、**arrayIndexScale（获取数组中元素的增量地址）** 配合起来使用，就可以`定位数组中每个元素在内存中的位置`。
    
     *  由于Java的数组最大值为`Integer.MAX_VALUE`**，使用Unsafe类的内存分配方法可以实现`超大数组`**。实际上这样的数据就可以认为是C数组，因此需要注意`在合适的时间释放内存`。

public native long staticFieldOffset(Field var1);
    
    public native long objectFieldOffset(Field var1);//(常用)
    
    public native Object staticFieldBase(Field var1);
    
    public native int arrayBaseOffset(Class<?> var1);
    
    public native int arrayIndexScale(Class<?> var1);

*  staticFieldOffset()：用于获取静态属性Field在对象中的偏移量，读写静态属性时必须获取其偏移量。这个值对于给定的字段是`唯一且固定不变的`
 *  objectFieldOffset()：用于获取非静态属性Field在对象实例中的偏移量，读写对象的非静态属性时会用到这个偏移量。
 *  staticFieldBase()：获取一个静态类中给定字段的对象指针
 *  arrayBaseOffset()：用于返回数组中第一个元素实际地址相对整个数组对象的地址的偏移量。
 *  arrayIndexScale()：返回数组中每个元素占用的内存大小,单位是字节

**测试: 静态属性读取**

@Test
        public void staticTest() throws Exception { 
            Unsafe unsafe = getUnsafe();
    
            //首先创建一个People 对象，这是因为如果一个类没有被实例化，那么它的静态属性也不会被初始化，最后获取的字段属性将是null。
            //所以在获取静态属性前，需要调用shouldBeInitialized方法，判断在获取前是否需要初始化这个类。如果删除创建Unsafe 对象的语句，运行结果会变为：getObject会返回null
            People people=new People();
        
        	//是否需要实例化一个类，通常在获取一个静态属性的时候使用
            System.out.println("shouldBeInitialized >> " +unsafe.shouldBeInitialized(User.class));
    
            Field sexField = People.class.getDeclaredField("name");
            long fieldOffset = unsafe.staticFieldOffset(sexField);
            System.out.println("staticFieldOffset >> " +fieldOffset);
    
            Object fieldBase = unsafe.staticFieldBase(sexField);
            System.out.println("staticFieldBase >> " +fieldBase);
    
            Object object = unsafe.getObject(fieldBase, fieldOffset);
            System.out.println("getObject >> " +object);
        }
    
        @Data
        public class People { 
            public static String name = "Hydra";
            private int age;
        }

测试结果  
![在这里插入图片描述][87f61ca841e34dfea9d8124c0b46a6c6.png]

## 3.直接内存操作 ##

**我们都知道`Java不可以直接对内存进行操作`，对象内存的分配和回收都是由`JVM`帮助我们实现的。但是`Unsafe为我们在Java中提供了直接操作内存的能力。`**

*  Unsafe能直接进行申请内存、释放内存、内存拷贝等操作。`需要注意`的是Unsafe直接申请的内存是 `堆外内存`。
    
     *  **什么是堆外内存呢？** 堆外是`相对于JVM的内存来说的`，通常我们应用程序运行后，创建的对象均在JVM内存中的堆中，**堆内存是由JVM来管理的**，`而堆外内存指的是计算机中的直接内存，不受JVM管理。` 因此使用Unsafe类来申请对外内存时，要特别注意，否则容易出现内存泄漏等问题。

// 分配内存
    public native long allocateMemory(long var1);
    // 重新分配内存
    public native long reallocateMemory(long var1, long var3);
    // 内存初始化
    public native void setMemory(long var1, long var3, byte var5);
    // 内存复制
    public native void copyMemory(Object var1, long var2, Object var4, long var5, long var7);
    // 清除内存
    public native void freeMemory(long var1);
    //获取内存地址
    getAddress(long var1)

**测试: 内存操作**

@Test
        public void memoryTest() { 
            Unsafe unsafe = getUnsafe();
    
            int size = 4;
            //(分配内存)使用allocateMemory方法申请4字节长度的内存空间,返回内存地址
            long allocateAddr = unsafe.allocateMemory(size);
            //(重新分配内存)使用reallocateMemory方法重新分配了一块8字节长度的内存空间,返回内存地址
            long reallocateAddr = unsafe.reallocateMemory(allocateAddr, size * 2);
            System.out.println("allocateAddr: " + allocateAddr);
            System.out.println("reallocateAddr: " + reallocateAddr);
    
    
            try { 
                //(内存初始化)调用setMemory方法向每个字节写入内容为byte类型的1
                unsafe.setMemory(null, allocateAddr, size, (byte) 1);
                for (int i = 0; i < 2; i++) { 
                    //（内存复制）调用copyMemory方法进行了两次内存的拷贝，每次拷贝内存地址allocateAddr开始的4个字节，分别拷贝到以reallocateAddr 和reallocateAddr+4开始的内存空间上：
                    unsafe.copyMemory(null, allocateAddr, null, reallocateAddr + size * i, 4);
                }
    
    			//当使用Unsafe调用getInt方法时，因为一个int型变量占4个字节，会一次性读取4个字节，组成一个int的值，对应的十进制结果为16843009，可以通过图示理解这个过程：
                System.out.println("allocateAddr: " + unsafe.getInt(allocateAddr));
                //拷贝完成后，使用getLong方法一次性读取8个字节，得到long类型的值为72340172838076673。
                System.out.println("reallocateAddr: " + unsafe.getLong(reallocateAddr));
            } finally { 
                //(内存释放)需要注意，通过这种方式分配的内存属于堆外内存，是无法进行垃圾回收的，需要我们把这些内存当做一种资源去手动调用freeMemory方法进行释放，否则会产生内存泄漏。
                // 通用的操作内存方式是在try中执行对内存的操作，最终在finally块中进行内存的释放。
                unsafe.freeMemory(allocateAddr);
                unsafe.freeMemory(reallocateAddr);
            }
        }

执行结果  
![在这里插入图片描述][58ed732a4dbe48438fd9ee4c587c2bf2.png]

> Unsafe类对内存的操作在网络通信框架中应用广泛，如：`Netty、MINA等通信框架`。在`java.nio包`中的`DirectByteBuffer`中，**内存的申请、释放等逻辑都是调用Unsafe类中的对应方法来实现的**。
> 
>  *  利用copyMemory()，我们可以实现一个通用的对象拷贝方法，无需再对每一个对象都实现clone方法，当然这通用的方法只能做到`对象浅拷贝。`

## 4.CAS相关 ##

JUC中大量运用了CAS操作，可以说`CAS操作是JUC的基础`，**Unsafe中提供了`int,long和Object`的CAS操作**：

**CAS(Compare And Swap，比较并交换)** 算法是一种无锁算法，属于乐观锁，是Java提供的`非阻塞原子性操作`。*在不使用锁的情况下实现多线程下的同步*。在并发包中(`java.util.concurrent.atomic`)**原子类型**都是使用CAS来实现的。

*  乐观锁的核心思路就是**每次不加锁而是假设修改数据之前其他线程一定不会修改，如果因为修改过产生冲突就失败就重试，直到成功为止**。
    
     *  **CAS算法是`非阻塞`的，多个线程竞争锁只会有一个胜出，其余线程并不会阻塞，而是继续尝试获取更新，当然也可以主动放弃。因此不可能出现死锁的情况。也就是说`无锁操作天生免疫死锁`。**
     *  CAS通过硬件保证了比较更新的原子性，在JDK中Unsafe类提供了一系列的`compareAndSwap*`方法，
        
         *  JVM中的CAS操作就是利用了**CPU提供的[cmpxchgl指令][cmpxchgl]实现的原子性的。**

/** * @param o 包含要修改field的对象 * @param offset 对象中某field的偏移量 * @param expected 期望值 * @param update 更新值 * 如果o+offset对应的的值与expected相同，则将字段的值设为update这个新值，并且此更新是不可被中断的，也就是一个原子操作。 * @return true | false */
    public final native boolean compareAndSwapObject(Object o, long offset,int expected,int update);
    
    public final native boolean compareAndSwapInt(Object o, long offset, int expected, int update);
    
    public final native boolean compareAndSwapLong(Object o, long offset, long expected, long update);

*  `CAS一般用于乐观锁`，在Java的锁中，经常会出现CAS操作，它们最终都调用了`Unsafe类中的CAS操作方法，compareAndSwapInt()、compareAndSwapLong()、compareAndSwapObject()`，这3个CAS方法都是`native方法`，具体实现是在`JVM中实现`，**它们的作用是比较并交换，这个操作是原子操作。** 关于CAS更详细的讲解可以参考这篇文章：[初识CAS的实现原理][CAS]

--------------------

Unsafe在`队列同步器AQS（AbstractQueuedSynchronizer）`、`原子类`中都有应用，现在以队列同步器AQS为例，看看AQS当中是如何使用Unsafe类的。

*  在AQS中获取`同步状态`时，如果当前线程能获取到锁，那么就会去尝试修改同步状态state的值，这个时候就用到了Unsafe类。`compareAndSetState()`是AQS类中的一个方法，它实际调用的是`Unsafe类的compareAndSwapInt()方法`。

protected final boolean compareAndSetState(int expect, int update) { 
    	    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    	}

--------------------

**测试**

public class CasTest { 
        private volatile int num;
        private Unsafe unsafe = UnsafeTest.getUnsafe();
    
        public static void main(String[] args) { 
            //使用两个线程去修改int型属性num的值，并且只有在num的值等于传入的参数x减一时，才会将num的值变为x，也就是实现对num的加一的操作
            CasTest cas = new CasTest();
    
            new Thread(() -> { 
                for (int i = 1; i < 50; i++) { 
                    cas.increment(i);
                    System.out.print(Thread.currentThread().getName() + ":" + cas.num + " ");
                }
            },"a").start();
    
    
            new Thread(() -> { 
                for (int i = 50; i < 100; i++) { 
                    cas.increment(i);
                    System.out.print(Thread.currentThread().getName() + ":" + cas.num + " ");
                }
            },"b").start();
    
    
            new Thread(() -> { 
                for (int i = 100; i < 150; i++) { 
                    cas.increment(i);
                    System.out.print(Thread.currentThread().getName() + ":" + cas.num + " ");
                }
            },"c").start();
    
            new Thread(() -> { 
                for (int i = 150; i < 200; i++) { 
                    cas.increment(i);
                    System.out.print(Thread.currentThread().getName() + ":" + cas.num + " ");
                }
            },"d").start();
        }
    
        /** * 自增 * * @param x */
        private void increment(int x) { 
            // 需要注意的是，在调用compareAndSwapInt方法后，会直接返回true或false的修改结果，因此需要我们在代码中手动添加自旋的逻辑。
            // 在AtomicInteger类的设计中，也是采用了将compareAndSwapInt的结果作为循环条件，直至修改成功才退出死循环的方式来实现的原子性的自增操作。
            while (true) { 
                try { 
                    long fieldOffset = UnsafeTest.getUnsafe().objectFieldOffset(CasTest.class.getDeclaredField("num"));
                    if (unsafe.compareAndSwapInt(this, fieldOffset, x - 1, x)) { 
                        break;
                    }
                } catch (NoSuchFieldException e) { 
                    e.printStackTrace();
                }
            }
        }
    }

执行结果  
![在这里插入图片描述][f5e2b680f2d74502ae18f848c6577f8b.png]

## 5.线程调度 ##

//取消阻塞线程
    public native void unpark(Object thread);
    //阻塞线程
    public native void park(boolean isAbsolute, long time);
    
    //获得对象锁（可重入锁）
    @Deprecated
    public native void monitorEnter(Object o);
    //释放对象锁,，如果对一个没有被monitorEnter加锁的对象执行此方法，会抛出IllegalMonitorStateException异常。
    @Deprecated
    public native void monitorExit(Object o);
    //尝试获取对象锁
    @Deprecated
    public native boolean tryMonitorEnter(Object o);

*  **park()和unpark()** 相信看过`LockSupport类`的都不会陌生，这两个方法主要用来`挂起和唤醒线程` 。 将一个线程进行挂起是通过`park()`实现的，调用 park()后，线程将一直阻塞直到超时或者中断等条件出现。`unpark()`可以终止一个挂起的线程，使其恢复正常。
 *  `monitorEnter`方法用于获得对象锁，`monitorExit`用于释放对象锁，如果对一个没有被`monitorEnter加锁`的对象执行此方法，会抛出`IllegalMonitorStateException异常`。`tryMonitorEnter方法`尝试获取对象锁，如果成功则返回true，反之返回false
    
     *  **Java中的`synchronized锁`就是通过这2个指令来实现的。** ，`monitor相关的3个方法`已经被标记为Deprecated，**不建议被使用**

**应用场景**： Java锁和同步器框架的核心类`AbstractQueuedSynchronizer`，就是通过调`用LockSupport.park()和LockSupport.unpark()`实现线程的`阻塞和唤醒`的，而LockSupport的park、unpark方法实际是调用Unsafe的park、unpark方式来实现。

//-------------------LockSupport的部分源码---------------------
    // 挂起线程
    public static void park(Object blocker) { 
        Thread t = Thread.currentThread();
        setBlocker(t, blocker); // 通过Unsafe的putObject方法设置阻塞阻塞当前线程的blocker
        UNSAFE.park(false, 0L); // 通过Unsafe的park方法来阻塞当前线程，注意此方法将当前线程阻塞后，当前线程就不会继续往下走了，直到其他线程unpark此线程
        setBlocker(t, null); // 清除blocker
    }
    
    // 唤醒线程
    public static void unpark(Thread thread) { 
        if (thread != null)
            UNSAFE.unpark(thread);
    }

--------------------

**测试：使用Unsafe的park()和unpark()**

@Test
        public void testParkAndUnpark() { 
            Unsafe unsafe = getUnsafe();
    
            Thread mainThread = Thread.currentThread();
            new Thread(() -> { 
                try { 
                    //休眠5s
                    TimeUnit.SECONDS.sleep(5);
                    System.out.println("子线程尝试唤醒主线程");
                    unsafe.unpark(mainThread);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }).start();
    
            System.out.println("阻塞主线程");
            unsafe.park(false, 0L);
            System.out.println("唤醒主线程成功");
        }

执行结果：线程开始运行后先进行睡眠，确保主线程能够调用`park方法`阻塞自己，子线程在睡眠5秒后，调用`unpark方法`唤醒主线程，使主线程能继续向下执行。如下图所示：  
![在这里插入图片描述][b022d880048541e788d6758f56df1235.png]

## 6.类加载相关 ##

public native Class<?> defineClass(String name, byte[] b, int off, int len,ClassLoader loader,ProtectionDomain protectionDomain);
    
    public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);
    
    public native Object allocateInstance(Class<?> c); throws InstantiationException;
    
    public native boolean shouldBeInitialized(Class<?> c);
    
    public native void ensureClassInitialized(Class<?> c);

*  **defineClass()**：定义一个类，用于在运行时动态地创建类（此方法会跳过JVM的所有安全检查）。
 *  **defineAnonymousClass()**：用于在运行时动态地创建匿名内部类。
    
    > 在Lambda表达式中就是使用ASM动态生成字节码，然后利用该方法定义实现相应的函数式接口的匿名类。
 *  **allocateInstance()**：用于创建一个类的实例，但是不会调用这个实例的构造方法，如果这个类还未被初始化，则初始化这个类。
    
    > 这个对象在对象反序列化的时候会很有用，能够重建和设置final字段，而不需要调用构造方法。
 *  **shouldBeInitialized()**：`判断是否需要初始化一个类`，通常在获取一个类的静态属性的时候使用（因为一个类如果没初始化，它的静态属性也不会初始化）。 当且仅当ensureClassInitialized方法不生效时返回false。
 *  **ensureClassInitialized()**：`检测给定的类是否已经初始化`。通常在获取一个类的静态属性的时候使用（因为一个类如果没初始化，它的静态属性也不会初始化）。

**典型应用**

*  **常规对象实例化方式**：通常我们使用new机制来的创建对象。当类只有有参构造函数且没有无参构造函数时，则必须使用有参构造函数进行对象实例化，且使用有参构造函数时，必须传递相应个数的参数才能完成对象实例化。
 *  **非常规的实例化方式**：而Unsafe中提供`allocateInstance方法`，仅通过Class对象就可以创建此类的实例对象，而且**不需要调用其构造函数、初始化代码、JVM安全检查等。它抑制修饰符检测**，也就是即使`构造器是private修饰的也能通过此方法实例化`，只需提供`class对象`即可创建相应的对象。由于这种特性，allocateInstance在java.lang.invoke、Objenesis（提供绕过类构造器的对象生成方式）、Gson（反序列化时用到）中都有相应的应用。

**测试1: 使用allocateInstance**

@Data
    public class A { 
        private int b;
        public A(){ 
            this.b =1;
        }
    }
    
    @Test
    public void objTest() throws Exception{ 
        A a1=new A();
        System.out.println(a1.getB());
        A a2 = A.class.newInstance();
        System.out.println(a2.getB());
        A a3= (A) unsafe.allocateInstance(A.class);
        System.out.println(a3.getB());
    }

执行结果： 打印结果分别为1、1、0，说明通过allocateInstance方法创建对象过程中，不会调用类的构造方法。使用这种方式创建对象时，只用到了Class对象，所以说如果想要跳过对象的初始化阶段或者跳过构造器的安全检查，就可以使用这种方法。在上面的例子中，如果将A类的构造函数改为private类型，将无法通过构造函数和反射创建对象，但allocateInstance方法仍然有效。

--------------------

**测试2: 使用defineClass在运行时动态地创建一个类**

*  在实际使用过程中，**可以只传入`字节数组`、`起始字节的下标`以及`读取的字节长`度**，默认情况下，`类加载器（ClassLoader）和保护域（ProtectionDomain）`来源于调用此方法的实例。下面的例子中实现了反编译生成后的class文件的功能：

@Test
        public void defineTest() { 
            Unsafe unsafe = getUnsafe();
    
            String fileName = "E:\\04_resource_study\\java_base_demo\\target\\classes\\com\\demo\\concurrent\\unsafe\\User.class";
    
            File file = new File(fileName);
            try (FileInputStream fis = new FileInputStream(file)) { 
                //缓存大小为文件大小
                byte[] content = new byte[(int) file.length()];
    
                //读取流
                fis.read(content);
    
                //动态创建class
                Class clazz = unsafe.defineClass(null, content, 0, content.length, null, null);
    
                //创建一个对象
                Object o = clazz.newInstance();
                Object age = clazz.getMethod("getAge").invoke(o, null);
    
                System.out.println(age);
            } catch (Exception e) { 
                e.printStackTrace();
            }
        }
    
    	@Data
    	public class User { 
        	private Integer age = 18;
    	}

执行结果  
![在这里插入图片描述][35ee1da0d01d41a8a51dd36aecf99e61.png]

## 7.内存屏障 ##

*  Unsafe类从JDK1.8开始，提供了三个和内存屏障相关的API方法。分别是**loadFence()、 storeFence() 、fullFence()**，用于**定义内存屏障，`避免代码重排序`。**

> 硬件层的内存屏障分为2种：Load Barrier 和 Store Barrier即读屏障和写屏障。  
> .  
> 内存屏障有2个作用：
> 
> 1.  阻止屏障两侧的指令重排序
> 2.  强制把写缓冲区/高速缓存中的脏数据等写回主内存，让缓存中相应的数据失效

*  loadFence() ：表示该方法之前的`所有load操作`在内存屏障之前完成。
 *  storeFence()：表示该方法之前的`所有store操作`在内存屏障之前完成。
 *  fullFence()：表示该方法之前的所有`load、store操作`在内存屏障之前完成。

// 禁止load操作重排序
    public native void loadFence();
    	
    // 禁止store操作重排序
    public native void storeFence();
    	
    // 禁止load和store操作重排序
    public native void fullFence();

**测试：**

@Test
        public void memoryBarrierTest() { 
            Unsafe unsafe = getUnsafe();
    
            ChangeThread changeThread = new ChangeThread();
            new Thread(changeThread).start();
    
            while (true) { 
                boolean flag = changeThread.isFlag();
    
                //加入读内存屏障
                unsafe.loadFence();
    
                if (flag) { 
                    System.out.println("detected flag changed");
                    break;
                }
            }
    
            System.out.println("main thread end");
        }
    
        @Getter
        ChangeThread implements Runnable { 
            /** * volatile **/
            boolean flag = false;
    
            @Override
            public void run() { 
                try { 
                    Thread.sleep(3000);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
                System.out.println("subThread change flag to:" + flag);
                flag = true;
            }
        }

执行结果  
![在这里插入图片描述][80e7f82e062643109e99f2c3782db710.png]  
而如果删掉上面代码中的`loadFence方法`，那么主线程将无法感知到`flag`发生的变化，会一直在`while中循环`。用图来表示上面的过程：  
![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 2]

*  了解`Java内存模型（JMM）`的小伙伴们应该清楚：**`运行中的线程不能直接操作主内存中的变量的，只能操作自己工作内存中的变量，然后同步到主内存中，并且线程的工作内存是不能共享的`。上面的图中的流程就是子线程借助于主内存，将修改后的结果同步给了主线程，进而修改主线程中的工作空间，跳出循环。**

**典型应用**

*  在Java 8中引入了一种锁的新机制——`StampedLock`，它可以看成是读写锁的一个改进版本。StampedLock提供了一种`乐观读锁`的实现，这种乐观读锁类似于无锁的操作，`完全不会阻塞写线程获取写锁`，从而缓解`读多写少时写线程“饥饿”现象`。
 *  由于StampedLock提供的乐观读锁不阻塞写线程获取读锁，当线程共享变量从主内存load到线程工作内存时，会存在数据不一致问题，所以当使用StampedLock的乐观读锁时，需要遵从如下图用例中使用的模式来确保数据的一致性。  
    ![在这里插入图片描述][watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 3]

## 8.系统相关 ##

*  Unsafe中提供的`addressSize`和`pageSize`方法用于获取系统信息
    
     *  调用addressSize方法会`返回系统指针的大小`，如果在**64位系统**下默认会返回`8`，而**32位系统**则会返回`4`。
     *  调用pageSize方法会返回`内存页的大小`，值为2的整数幂。

// 获取指针的大小，单位是字节。
    // 对于64位系统，返回8，表示指针大小是8字节
    // 对于32位系统，返回4，表示指针大小是4字节
    public native int addressSize();
    
    // 返回内存页的大小，单位是字节。返回值一定是2的多少次幂
    public native int pageSize();

**测试**

@Test
        public void systemTest() { 
            Unsafe unsafe = getUnsafe();
            System.out.println(unsafe.addressSize());
            System.out.println(unsafe.pageSize());
        }

执行结果：本人电脑的指针大小为8字节，内存页大小为4096字节，即4KB。

8
    4096

> 这两个方法的应用场景比较少，在`java.nio.Bits类`中，在使用pageCount计算所需的内存页的数量时，调用了`pageSize`方法获取内存页的大小。另外，在使用`copySwapMemory`方法拷贝内存时，调用了`addressSize`方法，检测`32位系统`的情况。

## 9.Unsafe具体实现的相关原子方法 ##

//原子方式将当前值与输入值相加并返回结果 
    	//获取内存地址为obj+offset的变量值, 并将该变量值加上delta
    	//obj: 当前要操作的对象（其实就是 AtomicInteger 实例）
        //offset: 当前要操作的变量偏移量（可以理解为 CAS 中的内存当前值）
    	//delta: 期望内存中的值
    	//v: 要修改的新值
    	public final int getAndAddInt(Object obj, long offset, int delta) { 
        	int v;
        	do { 
        	//通过对象和偏移量获取变量的值
        	//由于volatile的修饰, 所有线程看到的v都是一样的
            	v= this.getIntVolatile(obj, offset);
        	/* while中的compareAndSwapInt()方法尝试修改v的值,具体通过objoffset获取变量的值 如果这个值和v不一样, 说明其他线程修改了obj+offset地址处的值, 此时compareAndSwapInt()返回false, 继续循环 如果这个值和v一样, 说明没有其他线程修改obj+offset地址处的值, 此时可以将obj+offset地址处的值改为v+delta, compareAndSwapInt()返回true, 退出循环 Unsafe类中的compareAndSwapInt()方法是原子操作, 所以compareAndSwapInt()修改obj+offset地址处的值的时候不会被其他线程中断 */
    		//比较一下 offset 和内存当前值 v 是否相等，如果相等那我就将内存值 v 修改为 v + delta（delta 就是 1，也可以是其他数）。
        	} while(!this.compareAndSwapInt(obj, offset, v, v + delta));
    
        	return v;
    	}
    
    	//同上
        public final long getAndAddLong(Object var1, long var2, long var4) { 
            long var6;
            do { 
                var6 = this.getLongVolatile(var1, var2);
            } while(!this.compareAndSwapLong(var1, var2, var6, var6 + var4));
    
            return var6;
        }
        
    	//以原子方式设置为给定值并返回旧值
        public final int getAndSetInt(Object var1, long var2, int var4) { 
            int var5;
            do { 
                var5 = this.getIntVolatile(var1, var2);
            } while(!this.compareAndSwapInt(var1, var2, var5, var4));
    
            return var5;
        }
    	//同上
        public final long getAndSetLong(Object var1, long var2, long var4) { 
            long var6;
            do { 
                var6 = this.getLongVolatile(var1, var2);
            } while(!this.compareAndSwapLong(var1, var2, var6, var4));
    
            return var6;
        }
    	//同上
        public final Object getAndSetObject(Object var1, long var2, Object var4) { 
            Object var5;
            do { 
                var5 = this.getObjectVolatile(var1, var2);
            } while(!this.compareAndSwapObject(var1, var2, var5, var4));
    
            return var5;
        }

# 三.总结 #

*  Java并发编程中，存着这大量的Unsafe类的使用，主要使用的是和CAS操作相关的三个方法，所以搞清楚这三个方法，对看懂Java并发编程的源码有很大帮助。
 *  另外Unsafe类中`objectFieldOffset(Field f)这个方法很常用`，**它是`获取字段在内存中的偏移量`，通常和Unsafe类中的其他方法结合使用**。**通过这个方法能知道要修改的数据在内存中的位置，然后再通过Unsafe类中其他方法来根据数据在内存中的位置从而来修改数据。**

> 大家肯定想一探究竟`compareAndSwapXXX`和`objectFieldOffset` 这2个方法中做了什么事情，很遗憾，个人水平有限，目前还没有能力去探究，只知道这种写法是`JNI`，会调用到`C或者C++的系统调用`，最终会把对应的指令发送给CPU，这是可以保证原子性的。

**Unsafe确实存在着一些安全隐患，在我看来，一项技术具有不安全因素并不可怕，可怕的是它在使用过程中被滥用。尽管之前有传言说会在Java9中移除Unsafe类，不过它还是照样已经存活到了Java16，按照存在即合理的逻辑，只要使用得当，它还是能给我们带来不少的帮助，因此最后还是建议大家，在使用Unsafe的过程中一定要做到使用`谨慎使用、避免滥用`。**

--------------------

参考如下文章

*  [Java魔法类：Unsafe应用解析][Java_Unsafe]
 *  [Java双刃剑之Unsafe类详解][Java_Unsafe 1]

[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20221123/1bccc95cc98b4db4880e43825d4129e2.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20221123/b08eec14a34a43a89d0c1eb730714fef.png
[8a9cf40ebac14955b0010f7c1eb7cc00.png]: /images/20221123/9fe13f31bb264244937ff780d0c44c2c.png
[Java_JNI_JNI_ Java _ C]: https://blog.csdn.net/qq877728715/article/details/116664282
[5615af8cd0a24182a292eac2c20e2d85.png]: /images/20221123/f735b9f126c740cb872967be27c4431f.png
[87f61ca841e34dfea9d8124c0b46a6c6.png]: /images/20221123/546c4f1775f04e358b5fa5a16932f05e.png
[58ed732a4dbe48438fd9ee4c587c2bf2.png]: /images/20221123/086cf369c32847b2979bc80587dbdb97.png
[cmpxchgl]: https://faydoc.tripod.com/cpu/cmpxchg.htm
[CAS]: https://mp.weixin.qq.com/s/oe046IRUbYeXpIpYLz19ew
[f5e2b680f2d74502ae18f848c6577f8b.png]: /images/20221123/9f9724b0a20e43b39c070c299e6c1216.png
[b022d880048541e788d6758f56df1235.png]: /images/20221123/c05f805a96e041f3ac51e6e8d0df1587.png
[35ee1da0d01d41a8a51dd36aecf99e61.png]: /images/20221123/bff87663d01a45c48baac2888e6582da.png
[80e7f82e062643109e99f2c3782db710.png]: /images/20221123/32da7a9b71c44143b6f2f107672dbf2f.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20221123/8713ee83498e4ca49335c8cfecd34f6c.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBA5aKp5aKp5YiG5aKp_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20221123/52d3449c7d154874afe7b903c908c10e.png
[Java_Unsafe]: https://tech.meituan.com/2019/02/14/talk-about-java-magic-class-unsafe.html
[Java_Unsafe 1]: https://www.cnblogs.com/trunks2008/p/14720811.html