程序驿站

01.Unsafe类


阅读数: 次   
字数：4.4k字 | 预计阅读时长：19分钟

Unsafe

Java和C语言的一个重要区别就是，在Java中我们无法直接操作一块内存地址，但Java提供了一个特殊的类Unsafe工具类来间接实现。Unsafe主要提供一些用于执行低级别、不安全操作的方法，（如：直接访问系统内存资源、自主管理内存资源等）。

注：

  • Unsafe就和其名字一样，直接使用这个类是不安全的，它能直接在内存上修改访问变量，而无视各种访问修饰符的限制。它几乎所有的public方法都是native(本地方法)的，这些方法都是使用C/C++实现的，它越过了虚拟机层面，直接在操作系统本地执行。

  • 由于Unsafe是一个底层类，如果在不了解其内部原理并未掌握使用技巧的情况下，直接使用Unsafe类可能会造成一些意想不到或未知的错误，所以它被限制开发者直接使用，只能由JDK类库的维护者使用。如果看过JUC的源码，那么会发现在各种并发工具类的内部经常会通过使用这个类的一些方法根据相应内存地址在内存上直接CAS修改访问共享变量的值。

获取Unsafe类实例

Unsafe类是final的且构造函数是private的，只能通过静态方法getUnsafe()才能获取Unsafe单例对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public final class Unsafe {
    private static final Unsafe theUnsafe = new Unsafe();
    private Unsafe() {
    }

    @CallerSensitive
    public static Unsafe getUnsafe() {
        // 调用者Class对象。
        Class var0 = Reflection.getCallerClass();
        // 判断调用者的类加载器是否为系统类加载器。
        if (!VM.isSystemDomainLoader(var0.getClassLoader())) {
            // 如果不是JAVA_HOME/jre/lib目录下jar包中的类来调用此方法就会抛出异常。
            throw new SecurityException("Unsafe");
        } else {
            return theUnsafe;
        }
    }
    ...
}

然而此静态方法的使用也是受到限制的，只能由JDK中的其他类来调用，普通开发者使用此方法将抛出异常。

错误的获取Unsafe类实例

虽然无法实例化，但还是可以通过反射获取Unsafe类对象

1
2
3
4
5
6
public static Unsafe getUnsafe() throws IllegalAccessException {
    Field unsafeField = Unsafe.class.getDeclaredFields()[0];
    unsafeField.setAccessible(true);
    Unsafe unsafe = (Unsafe) unsafeField.get(null);
    return unsafe;
}

再次提示：由于Unsafe类为调用者提供执行不安全操作的能力，返回的Unsafe对象应该由调用方小心保护，绝不能将其传递给不受信任的代码。

Unsafe类的主要功能

Unsafe类主要功能

Java对象操作相关

获取字段相对偏移量

1
2
3
4
5
6
7
8
/**
 *  根据反射的字段f,获取相应实例变量的偏移量
 *  此偏移量是实例变量的起始地址与对象的起始地址之差，对于一个确定的java类，某字段与对象之间的起始地址之差是常数，
 *  静态变量的偏移量与此类似
 */
public native long staticFieldOffset(Field f);
// 根据反射的字段f,获取相应静态变量的偏移量（静态变量的起始地址与相应静态区Klass对象起始地址之差）
public native long objectFieldOffset(Field f);

这里提到字段的偏移量，这与Java对象的内存布局有密切关系。Java中对象由对象头和实际数据两部分组成。如下图：

Java对象内存模型

  • MarkWord包含对象的hashCode、锁信息、垃圾回收的分代信息等，占32/64位;
  • Class Metadata Pointer表示一个此对象数据类型的Class对象（虚拟机中的Klass对象）的指针，占32/64位;
  • ArrayLength是数组对象特有的内容，表示数组的长度，占32位。数组对象的实际数据是各个元素的值或引用，普通对象的实际数据是各实例字段的值或引用。
  • 另外为了快速分配内存、快速内存寻址、调高性能，Java语言规范要求Java对象要做内存对齐处理，每个对象占用的内存字节数必须是8的倍数，若不是则要填0补位对齐。

从上图可用看出，字段与对象头之间的偏移量是固定的，只要知道字段的相对偏移量和对象起始地址，我们就能获取此字段的绝对内存地址（fieldAddress = objAddress + fieldOffset），根据此绝对内存地址，我们就能忽略访问修饰符的限制而可以直接读取/修改此字段的值或引用。

注：数组对象的元素内存地址，相对于普通对象的字段地址有些不一样，它要先计算出对象头的长度，作为基础偏移量；

由于数组元素的数据类型是相同的，每个元素的值或引用所占用的内存空间是相同的，因此将元素值或引用所占内存作为每两个相邻元素的相对偏移量。根据对象起始位置、基础偏移量、相邻元素相对偏移量及数组下标，就可以获取到某个元素值或引用的绝对内存地址（itemAddress = arrayAddress + baseOffset + index * indexOffset）,进而通过绝对内存地址读取或修改此元素的值或引用。

根据字段偏移量设置/获取字段值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
 * 参数o是字段所属的对象，offset表示相对偏移量，参数x是此字段要设置的新值
 * 字段是引用数据类型：获取字段值
 */
public native Object getObject(Object o, long offset);
// 字段是引用数据类型：设置字段值
public native void putObject(Object o, long offset, Object x);

// 字段为基本数据类型
public native void putInt(Object o, long offset, int x);
public native int getInt(Object o, long offset);
public native boolean getBoolean(Object o, long offset);
public native void    putBoolean(Object o, long offset, boolean x);
public native byte    getByte(Object o, long offset);
public native void    putByte(Object o, long offset, byte x);
public native short   getShort(Object o, long offset);
public native void    putShort(Object o, long offset, short x);
public native char    getChar(Object o, long offset);
public native void    putChar(Object o, long offset, char x);
public native long    getLong(Object o, long offset);
public native void    putLong(Object o, long offset, long x);
public native float   getFloat(Object o, long offset);
public native void    putFloat(Object o, long offset, float x);
public native double  getDouble(Object o, long offset);
public native void    putDouble(Object o, long offset, double x);

volatile版本根据字段偏移量设置/获取字段值

被volatile修饰时可以保证对其他线程的可见性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// volatile形式地获取字段值，即使在多线条件下，从主内存中获取值，使当前线程的工作内存的缓存值失效
public native Object getObjectVolatile(Object o, long offset);
// volatile形式地设置字段值，即使在多线条件下，设置的值将只保存到主内存中，不加载到线程本地缓存，保证可见性
public native void    putObjectVolatile(Object o, long offset, Object x);
public native int     getIntVolatile(Object o, long offset);
public native void    putIntVolatile(Object o, long offset, int x);
public native boolean getBooleanVolatile(Object o, long offset);
public native void    putBooleanVolatile(Object o, long offset, boolean x);
public native byte    getByteVolatile(Object o, long offset);
public native void    putByteVolatile(Object o, long offset, byte x);
public native short   getShortVolatile(Object o, long offset);
public native void    putShortVolatile(Object o, long offset, short x);
public native char    getCharVolatile(Object o, long offset);
public native void    putCharVolatile(Object o, long offset, char x);
public native long    getLongVolatile(Object o, long offset);
public native void    putLongVolatile(Object o, long offset, long x);
public native float   getFloatVolatile(Object o, long offset);
public native void    putFloatVolatile(Object o, long offset, float x);
public native double  getDoubleVolatile(Object o, long offset);
public native void    putDoubleVolatile(Object o, long offset, double x);

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

有序延迟化的设置字段值

有序延迟化设置值，对其他线程不保证可见性。

1
2
3
4
5
6
// 有序延迟化地设置字段值，
public native void putOrderedObject(Object o, long offset, Object x);

public native void putOrderedInt(Object o, long offset, int x);

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

数组相关的偏移量

1
2
3
4
5
// 第一个元素与数组对象两者间起始地址之差(首元素与对象头的相对偏移量）
public native int arrayBaseOffset(Class<?> arrayClass);

// 相邻元素间相对偏移量的位移表示(返回值的二进制形式的有效位数是x，那么相邻元素的偏移量就是2的x次方)
public native int arrayIndexScale(Class<?> arrayClass);

源码示例

此示例是JUC atomic包下的AtomicIntegerArray结合以上两个方法进行数组元素地址定位。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class AtomicIntegerArray implements java.io.Serializable {
    private static final long serialVersionUID = 2862133569453604235L;

    private static final Unsafe unsafe = Unsafe.getUnsafe();
    private static final int   base   = unsafe.arrayBaseOffset(int[].class);
    private static final int   shift;
    private final        int[] array;
    static {
        int scale = unsafe.arrayIndexScale(int[].class);
        if ((scale & (scale - 1)) != 0)
            throw new Error("data type scale not a power of two");
        shift = 31 - Integer.numberOfLeadingZeros(scale);
    }
    private long checkedByteOffset(int i) {
        if (i < 0 || i >= array.length)
            throw new IndexOutOfBoundsException("index " + i);

        return byteOffset(i);
    }
    private static long byteOffset(int i) {
        return ((long) i << shift) + base;
    }
    public final void set(int i, int newValue) {
        unsafe.putIntVolatile(array, checkedByteOffset(i), newValue);
    }
}

Class相关操作

创建Java类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 让虚拟机知道我们定义一个类，但不进行安全检查。 
 * 默认情况下，类加载器和保护域来自调用者的类。
 */
public native Class<?> defineClass(String name, byte[] b, int off, int len,
                                   ClassLoader loader,
                                   ProtectionDomain protectionDomain);

/*
 * 在类加载器和系统字典（system dictionary)不知道的情况下根据字节码数据定义一个匿名的Class对象，相当于创建了一个Java类
 * @params hostClass context for linkage, access control, protection domain, and class loader
 * @params data     字节码文件对应的字节数组
 * @params cpPatches where non-null entries exist, they replace corresponding CP entries in data
 */
public native Class<?> defineAnonymousClass(Class<?> hostClass, byte[] data, Object[] cpPatches);

Java类初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * Detect if the given class may need to be initialized. This is often
 * needed in conjunction with obtaining the static field base of a
 * class.
 * @return false only if a call to {@code ensureClassInitialized} would have no effect
 */
public native boolean shouldBeInitialized(Class<?> c);

/**
 * Ensure the given class has been initialized. This is often
 * needed in conjunction with obtaining the static field base of a
 * class.
 */
public native void ensureClassInitialized(Class<?> c);
  • shouldBeInitialized(Class)：检测对应的Java类是否被初始化。
  • ensureClassInitialized(Class)：强制Java类初始化，若没有初始化则进行初始化。

这两个方法常与staticFieldBase(Field)一起使用，因为如果Java类没有被初始化，静态变量便没有初始化，就不能直接获取静态变量的引用。

源码示例

java.lang.invoke.DirectMethodHandle中的checkInitialized(MemberName)方法调用了以上两个与类初始化相关的方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
private static boolean checkInitialized(MemberName member) {
    Class<?> defc = member.getDeclaringClass();
    WeakReference<Thread> ref = EnsureInitialized.INSTANCE.get(defc);
    if (ref == null) {
        return true;  // the final state
    }
    Thread clinitThread = ref.get();
    // Somebody may still be running defc.<clinit>.
    if (clinitThread == Thread.currentThread()) {
        // If anybody is running defc.<clinit>, it is this thread.
        if (UNSAFE.shouldBeInitialized(defc))
            // Yes, we are running it; keep the barrier for now.
            return false;
    } else {
        // We are in a random thread.  Block.
        UNSAFE.ensureClassInitialized(defc);
    }
    assert(!UNSAFE.shouldBeInitialized(defc));
    // put it into the final state
    EnsureInitialized.INSTANCE.remove(defc);
    return true;
}

根据Class创建对象

仅通过Class对象就可以创建此类的实例对象，而且不需要调用其他构造函数、初始化代码、JVM安全检查等。它抑制修饰符检测，也就是即使构造器是private修饰的也能通过此方法实例化。

1
2
3
4
/** Allocate an instance but do not run any constructor.
    Initializes the class if it has not yet been. */
public native Object allocateInstance(Class<?> cls)
    throws InstantiationException;

代码示例

私有化Employee类的唯一构造方法，让外界不能直接创建此类的对象；

下面通过allocateInstance(Class)方法和反射分别来创建Employee对象，看有什么区别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
package net.ityizhan.juc;

import sun.misc.Unsafe;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

/**
 * @ClassName : Employee
 * @Description :
 * @Author : https://www.ityizhan.net
 * @Date: 2021-03-13 18:52
 * @Version: 1.0.0
 */
public class Employee {
    private static int count;
    private static long countL = 1000;
    private long id;
    private String name;
    private int sex;// 1代表男性，0代表女性
    private long mgrId = 11111;

    static {
        count = 1000;// 目前员工人数的基数
    }

    private Employee() {
        sex = 1;// 默认为男性
        name = "";
        count++;
        countL++;
    }

    @Override
    public String toString() {
        return "{Employee [id=" + id + ", name=" + name + ", sex=" + sex + ", mgrId=" + mgrId
                + "]}" + " ,{count=" + count + ", countLong=" + countL + "}";
    }
}

class EmployeeTest {
    private static final Unsafe UNSAFE;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);
            UNSAFE = (Unsafe) f.get(null);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    public static void main(String[] args) throws Exception {
        Employee employee = (Employee) UNSAFE.allocateInstance(Employee.class);
        System.out.println("Unsafe创建的对象：" + employee);

        Class<Employee> clazz = Employee.class;
        Constructor<Employee> constructor = clazz.getDeclaredConstructor();
        constructor.setAccessible(true);
        Employee emp = constructor.newInstance();
        System.out.println("反射创建的对象：" + emp);
    }
}

结果如下：

1
2
Unsafe创建的对象：{Employee [id=0, name=null, sex=0, mgrId=0]} ,{count=1000, countLong=1000}
反射创建的对象：{Employee [id=0, name=, sex=1, mgrId=11111]} ,{count=1001, countLong=1001}

从控制台输出的信息可以看出，反射与Unsafe均能创建一个构造方法被私有化的对象。不同之处在于allocateInstance(Class)方法创建对象过程中不会进行对象初始化，但会进行类初始化，既不会执行实例变量初始化赋值、不执行构造代码块、不调用构造方法，但会执行静态变量的初始化赋值、执行静态代码块。

CAS更新操作

CAS是Java并发编程的最底层依据，它实现了非阻塞式地更新共享变量，自旋锁与乐观锁的实现均依赖它。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * CAS更新共享变量
 *
 * @param o        字段所属对象
 * @param offset   字段的相对偏移量
 * @param expected 预期值
 * @param x        更新值
 * @return 更新成功则返回true
 */
public final native boolean compareAndSwapObject(Object o, long offset, Object expected, Object x);

public final native boolean compareAndSwapInt(Object o, long offset, int expected, int x);

public final native boolean compareAndSwapLong(Object o, long offset, long expected, long x);

源码示例

同步容器AQS中的compareAndSetXxx方法都是直接委托上面的CAS方法实现的。

AQS类中的CAS方法

内存操作

根据内存地址设置/获取对应的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 *  参数address是绝对内存地址，参数x是设定的值
 *  如果address是零或不是通过allocMemery()方法分配的地址，那么结果未定义
 */
public native byte    getByte(long address);
public native void    putByte(long address, byte x);
/** @see #getByte(long) */
public native short   getShort(long address);
/** @see #putByte(long, byte) */
public native void    putShort(long address, short x);
/** @see #getByte(long) */
public native char    getChar(long address);
/** @see #putByte(long, byte) */
public native void    putChar(long address, char x);
/** @see #getByte(long) */
public native int     getInt(long address);
/** @see #putByte(long, byte) */
public native void    putInt(long address, int x);
/** @see #getByte(long) */
public native long    getLong(long address);
/** @see #putByte(long, byte) */
public native void    putLong(long address, long x);
/** @see #getByte(long) */
public native float   getFloat(long address);
/** @see #putByte(long, byte) */
public native void    putFloat(long address, float x);
/** @see #getByte(long) */
public native double  getDouble(long address);
/** @see #putByte(long, byte) */
public native void    putDouble(long address, double x);

根据内存地址设置/获取指针

1
2
3
4
5
// 根据内存地址获取一个指针
public native long getAddress(long address);

// 根据内存地址设置一个指针，adress是内存地址，x是指定的指针值
public native void putAddress(long address, long x);

分配、扩展、释放内存

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 分配一块指定的内存空间，返回一个指向此内存起始位置的指针
public native long allocateMemory(long bytes);

// 扩展内存
public native long reallocateMemory(long address, long bytes);

// 在指定的内存块填充值
public native void setMemory(Object o, long offset, long bytes, byte value);

public void setMemory(long address, long bytes, byte value) {
    setMemory(null, address, bytes, value);
}
// 将一处内存的数据复制另一处内存
public native void copyMemory(Object srcBase, long srcOffset,
                              Object destBase, long destOffset,
                              long bytes);
public void copyMemory(long srcAddress, long destAddress, long bytes) {
    copyMemory(null, srcAddress, null, destAddress, bytes);
}
// 释放内存
public native void freeMemory(long address);

源码示例

java.nio包下的DirectByteBuffer类的构造方法调用Unsafe.allocateMemory(int)分配初始条件下的内存缓冲区

Unsafe.allocateMemory(int)的实际应用

DirectByteBuffer的静态内部类Deallocator的run()调用Unsafe.freeMemory(long)释放相应地址的内存空间

Unsafe.freeMemory(long)的实际应用

系统信息

获取指定款第、内存也大小等系统软硬件信息，这些信息对于本地内存的分配、使用、寻址很重要。

1
2
3
4
5
6
7
// 本地指针宽度，通常是4或8
public native int addressSize();

/**
 * 内存页的大小，它总是2的幂次方
 */
public native int pageSize();

源码示例

sun.nio.ch包下NativeObject类的addressSize（）方法直接委托Unsafe.addressSize()实现

Unsafe.addressSize()的实际应用

java.nio包下Bit类pageSize()方法:当pageSize非法时，将Unsafe.pageSize()作为返回值

Unsafe.pageSize()的实际应用

可以看出addressSize()、pageSize()方法的调用者都是nio相关类，这是因为nio是直接使用JVM堆外的本地内存。

线程管理

唤醒/休眠线程

1
2
3
4
// 唤醒
public native void unpark(Object thread);
// 休眠
public native void park(boolean isAbsolute, long time);

以上两个方法是 等待/通知模型 的关键，它们是并发编程中使用到的底层方法。以上两个方法主要被LockSupport类直接引用，LockSupport.parkUntil(long)、LockSupport.unpark(Thread)方法中没有其他逻辑，就是直接委托以上两个方法实现的。

源码示例

1
2
3
4
5
6
public static void park() {
	UNSAFE.park(false, 0L);
}
public static void parkUntil(long deadline) {
    UNSAFE.park(true, deadline);
}

抢锁与释放锁(已弃用)

1
2
3
4
5
6
7
8
9
// 获取锁对象
@Deprecated
public native void monitorEnter(Object o);
// 释放锁对象
@Deprecated
public native void monitorExit(Object o);
// 尝试获取锁对象
@Deprecated
public native boolean tryMonitorEnter(Object o);

内存屏障

这些方法在Java8中引入，用于定义内存屏障（是CPU或编译器在对内存随机访问的操作中的一个同步点，使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作），避免代码重排序。

1
2
3
4
5
6
7
8
// 内存屏障，禁止load重排序。屏障前不能重排序load,且只能在屏障后load或store
public native void loadFence();

// 内存屏障，禁止store重排序。 屏障前不能重排序store操作,且只能在屏障后load或store
public native void storeFence();

// 内存屏障，禁止store load重排序。
public native void fullFence();

源码示例

loadFence()方法在StampedLock的validate方法有使用到，StampedLock是为了防止CAS更新时出现ABA问题而在JDK1.8新引入的并发工具。

loadFence()的实际应用

赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码
程序驿站

本文标题: 01.Unsafe类

文章作者: 程序驿站

发布时间: 2021-03-20

最后更新: 2021-05-24

版权声明: 本文为「程序驿站」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。

本文链接: http://www.ityizhan.net/code/101010/

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true