当前位置: 首页>移动开发>正文

继承 ConstraintLayout android kotlin 继承无限游戏安全屋

java为什么会引入unsafe类

  sun.misc.Unsafe至少从2004年Java1.4开始就存在于Java中了。在Java9中,为了提高JVM的可维护性,Unsafe和许多其他的东西一起都被作为内部使用类隐藏起来了。但是究竟是什么取代Unsafe不得而知,个人推测会有不止一样来取代它,那么问题来了,到底为什么要使用Unsafe?

做一些Java语言不允许但是又十分有用的事情

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_内存地址,第1张

JDK底层的unsafe开始讲起,concurrent包下的很多都是依赖于unsafe提供的操作

一、Unsafe简介

sun.misc.Unsafe类型从名字看,这个类应该是封装了一些不安全的操作。是JDK提供的一个工具类unsafe里面的方法大多是native方法,你可以理解为unsafe类是JDK给你提供的一个直接调用操作系统底层功能的一个工具类,unsafe提供了非常多操作系统级别的方法

(1)比如说通过unsafe可以让操作系统直接给你分配内存、释放内存。提供便利的同时也隐藏着很多风险。

(2)突破java语法本身的限制,直接从内存级别去操作堆里面的某个对象的数据

(3)调用操作系统的CAS指令,实现CAS的功能

(4)操作系统层次将线程挂起和恢复

(5)提供操作系统级别的内存屏障(之前说过的Load屏障和Store屏障),读取数据强制走主存,修改数据直接刷新到主存

总之unsafe就相当于JDK给你提供的一个直接跟操作系统打交道的一个工具类,通过unsafe可做一些非常底层的指令和行为。

这个类尽管里面的方法都是public的,但是并没有办法使用它们,JDK API文档也没有提供任何关于这个类的方法的解释。总而言之,对于Unsafe类的使用都是受限制的,只有授信的代码才能获得该类的实例,当然JDK库里面的类是可以随意使用的。

unsafe提供的这些操作系统级别的方法对于JDK底层的一些工具类、上层的一些框架来说在实现层方便了许多。比如著名的并发基础工具类AQS底层就是通过unsafe提供的CAS操作来进行加锁的,加锁失败的线程又是通过unsafe提供的park、unpark操作将线程挂起和唤醒的。还有一些非常著名的开源框架比如netty分配直接内存的方式底层也还是通过unsafe分配直接内存。

 

从第一行的描述可以了解到Unsafe提供了硬件级别的操作,比如说获取某个属性在内存中的位置,比如说修改对象的字段值,即使它是私有的。不过Java本身就是为了屏蔽底层的差异,对于一般的开发而言也很少会有这样的需求。

举两个例子,比方说:

public native long staticFieldOffset(Field paramField);

这个方法可以用来获取给定的paramField的内存地址偏移量,这个值对于给定的field是唯一的且是固定不变的。

二、Unsafe源码分析

2.1、类图结构

2.2、数据结构

2.2、Unsafe中的lock

2.3、成员变量

2.3、构造函数

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

*不能直接new Unsafe(),原因是Unsafe被设计成单例模式,构造方法是私有的;

*不能通过调用Unsafe.getUnsafe()获取,因为getUnsafe被设计成只能从引导类加载器(bootstrap class loader)加载,从getUnsafe的源码中也可以看出来;

JDK的开发人员并不希望大家使用这个类。获得Unsafe实例的方法是只能调用其工厂方法getUnsafe()。上面其中的if(!VM.isSystemDomainLoader(class1.getClassLoader()))的判断是为了只有JDK内部类调用。其它应用层调用它都报错。
示例1:通过下面的例子可以测试:

package com.dxz.unsafe;
public class Test {

    public static void main(String[] args) {
        sun.misc.Unsafe u = sun.misc.Unsafe.getUnsafe();
        System.out.println(u);
    }
}

在if(!VM.isSystemDomainLoader(class1.getClassLoader()))处打个断点,然后watch下Reflection.getCallerClass()的值,如下图:

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_工具类_02,第2张

说明:根据Java 类加载器的工作原理,应用程序的类由AppLoader加载。而系统核心类,如rt.jar中的类由Bootstrap类加载器加载。Bootstrap加载器没有Java对象的对象,因此试图获得这个类加载器会返回null。所以,当一个类的类加载器为null时,说明它是由Bootstrap加载的,而这个类也极有可能是rt.jar中的类。

三、Unsafe类提供了硬件级别的原子操作,主要提供了以下功能:

1、通过Unsafe类可以分配内存,可以释放内存;

类中提供的3个本地方法allocateMemory、reallocateMemory、freeMemory分别用于分配内存,扩充内存和释放内存,与C语言中的3个方法对应。

// 分配bytes大小的堆外内存
public native long allocateMemory(long bytes);
// 还可以执行从address处开始分配,分配bytes大小的堆外内存
public native long reallocateMemory(long address, long bytes);
// 释放allocateMemory和reallocateMemory申请的内存块
public native void freeMemory(long address);
// 将指定对象的给定offset偏移量内存块中的所有字节设置为固定值
// 相当于直接让你在内存级别直接给这个对象的变量赋值了
public native void setMemory(Object o, long offset, long bytes, byte value);

 

2、可以定位对象某字段的内存位置,也可以修改对象的字段值,即使它是私有的;

// 设置给定内存地址的long值
// 相当于直接在内存级别给address后面的8个字节赋值
public native void putLong(long address, long x);
// 获取指定内存地址的long值
// 相当于获取address后面的8个字节的值,然后转化为十进制的long值给你
public native long getLong(long address);
// 设置或获取指定内存的byte值
// 相当于获取address后面一个字节的数据,转化成十进制返回给你
public native byte  getByte(long address);
// 直接在内存级别给adderess地址后面的1个字节设置
public native void  putByte(long address, byte x);

字段的定位:
JAVA中对象的字段的定位可能通过native staticFieldOffset方法实现,该方法返回给定field的内存地址偏移量,这个值对于给定的filed是唯一的且是固定不变的。
native getIntVolatile方法获取对象中offset偏移地址对应的整型field的值,支持volatile load语义。
native getLong方法获取对象中offset偏移地址对应的long型field的值。
数组元素定位:
Unsafe类中有很多以BASE_OFFSET结尾的常量,比如ARRAY_INT_BASE_OFFSET,ARRAY_BYTE_BASE_OFFSET等,这些常量值是通过arrayBaseOffset方法得到的。arrayBaseOffset方法是一个本地方法,可以获取数组第一个元素的偏移地址。Unsafe类中还有很多以INDEX_SCALE结尾的常量,比如 ARRAY_INT_INDEX_SCALE , ARRAY_BYTE_INDEX_SCALE等,这些常量值是通过arrayIndexScale方法得到的。arrayIndexScale方法也是一个本地方法,可以获取数组的转换因子,也就是数组中元素的增量地址。将arrayBaseOffset与arrayIndexScale配合使用,可以定位数组中每个元素在内存中的位置。

public final class Unsafe {
    public static final int ARRAY_INT_BASE_OFFSET;
    public static final int ARRAY_INT_INDEX_SCALE;

    public native long staticFieldOffset(Field field);
    public native int getIntVolatile(Object obj, long l);
    public native long getLong(Object obj, long l);
    public native int arrayBaseOffset(Class class1);
    public native int arrayIndexScale(Class class1);

    static 
    {
        ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset([I);
        ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale([I);
    }
}

3、挂起与恢复

unsafe类提供类将一个线程挂起、讲一个挂起的线程唤醒的方法,分别是park和unpark。

park方法:

//线程调用该方法,线程将一直阻塞直到被唤醒,或者超时,

//或者中断条件出现。
public native void park(boolean isAbsolute, long time);

(1) isAbsolute是否是绝对时间,当isAbsolute == true ,后面time的时间单位是ms;当为false的时候,后面time参数的时间单位是ns。

(2)time > 0时候,表示大概要将线程挂起time的时间,过了时间后自动将线程唤醒。当time = 0的时候,表示一直将线程挂起,直到有人调用unpark方法将线程唤醒。

unpark方法:

public native void unpark(Object thread);

直接将正在被挂起的thread线程唤醒,让它继续干活.

整个并发框架中对线程的阻塞和唤醒功能操作被封装在LockSupport类中,LockSupport类中有各种版本pack方法,但最终都调用了Unsafe.park()方法。

public class LockSupport {
    public static void unpark(Thread thread) {
        if (thread != null)
            unsafe.unpark(thread);
    }

    public static void park(Object blocker) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(false, 0L);
        setBlocker(t, null);
    }

    public static void parkNanos(Object blocker, long nanos) {
        if (nanos > 0) {
            Thread t = Thread.currentThread();
            setBlocker(t, blocker);
            unsafe.park(false, nanos);
            setBlocker(t, null);
        }
    }

    public static void parkUntil(Object blocker, long deadline) {
        Thread t = Thread.currentThread();
        setBlocker(t, blocker);
        unsafe.park(true, deadline);
        setBlocker(t, null);
    }

    public static void park() {
        unsafe.park(false, 0L);
    }

    public static void parkNanos(long nanos) {
        if (nanos > 0)
            unsafe.park(false, nanos);
    }

    public static void parkUntil(long deadline) {
        unsafe.park(true, deadline);
    }
}

由于我们自己编写的java程序不能直接使用unsafe工具类,所以啊JDK还是有一些工具类对unsafe类的功能进行封装,然后我们就直接使用这些封装的工具类即可。

4、CAS操作

这块内容比较重要,JUC提供的很多Atomic原子类基于AQS实现的并发工具,底层都是通过CAS操作去实现的。下面我们就说说unsafe提供的cas操作:

是通过compareAndSwapXXX方法实现的

/**
* 比较obj的offset处内存位置中的值和期望的值,如果相同则更新。此更新是不可中断的。
* 
* @param obj 需要更新的对象
* @param offset obj中整型field的偏移量
* @param expect 希望field中存在的值
* @param update 如果期望值expect与field的当前值相同,设置filed的值为这个新值
* @return 如果field的值被更改返回true
*/
public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update);

简单来说CAS操作涉及三个值,分别是待修改的值E,要修改后的新值V,以及待修改值所对应的内存位置的取值N。

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_数据_03,第3张

 

(1)首先读取并记录待修改的值E
(2)然后计算新值V
(3)比较E和该内存位置的值,如果相等->(4);如果不相等->(5);
(4)更新为新值
(5)更新失败

看下natUnsafe.cc中的c++实现吧,加深理解,其实就是将内存值与预期值作比较,判断是否相等,相等的话,写入数据,不相等不做操作,返回旧数据;

static inline bool
compareAndSwap (volatile jint *addr, jint old, jint new_val)
{
  jboolean result = false;
  spinlock lock;
  if ((result = (*addr == old)))
    *addr = new_val;
  return result;
}

5、putLong,putInt,putDouble,putChar,putObject等方法,直接修改内存数据(可以越过访问权限)

上面的这些方法不受java语法的限制,提供内存级别的直接获取数据,修改数据的方式;unsafe操作内存这块内存我们目前只需要了解即可,对我们后续并发的学习影响不大。

比如说某个对象的private int value属性,这里的value属性是private的,如果这个对象没有提供对应的访问方法,在对象外部是访问不到这个value属性的对不对?
正常来说只有在对象的内部可以访问这个private属性,外部是访问不到的
然而这个对象的数据本质上还是保存在内存里面的,而unsafe提供了直接对某个内存地址读取、修改的操作,这样就可以突破java语法的限制了。

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_内存地址_04,第4张

相当于就是直接通过内存地址address找到这块内存然后直接操作这个内存块的数据了。就是直接操作内存块的数据,接下来我们再讲讲unsafe提供的cas操作。

这里,还有put对应的get方法,很简单就是直接读取内存地址处的数据,不做举例;

 我们可以举个putLong(Object, long, long)方法详细看下其具体实现,其它的类似,先看Java的源码,没啥好看的,就声明了一个native本地方法:

三个参数说明下:

Object o//对象引用
long offset//对象内存地址的偏移量
long x//写入的数据
public native void    putLong(Object o, long offset, long x);

还是看下natUnsafe.cc中的c++实现吧,很简单,就是计算要写入数据的内存地址,然后写入数据,如下:

void
sun::misc::Unsafe::putLong (jobject obj, jlong offset, jlong value)
{
  jlong *addr = (jlong *) ((char *) obj + offset);//计算要修改的数据的内存地址=对象地址+成员属性地址偏移量
  spinlock lock;//自旋锁,通过循环来获取锁, i386处理器需要加锁访问64位数据,如果是int,则不需要改行代码
  *addr = value;//往该内存地址位置直接写入数据
}

示例2:即使User类的成员属性是私有的且没有提供对外的public方法,我们还是可以直接在它们的内存地址位置处写入数据,并成功;

package com.dxz.unsafe;

import java.lang.reflect.Field;

import sun.misc.Unsafe;

class User {
    private String name = "test";
    private long id = 1;
    private int age = 2;
    private double height = 1.72;

    @Override
    public String toString() {
        return name + "," + id + "," + age + "," + height;
    }
}

public class Test2 {
    public static void main(String[] args) throws NoSuchFieldException, SecurityException, IllegalArgumentException,
            IllegalAccessException, InstantiationException {
        // 通过反射得到theUnsafe对应的Field对象
        Field field = Unsafe.class.getDeclaredField("theUnsafe");
        // 设置该Field为可访问
        field.setAccessible(true);
        // 通过Field得到该Field对应的具体对象,传入null是因为该Field为static的
        Unsafe unsafe = (Unsafe) field.get(null);

        User user = new User();
        System.out.println(user); // 打印test,1,2,1.72

        Class userClass = user.getClass();
        Field name = userClass.getDeclaredField("name");
        Field id = userClass.getDeclaredField("id");
        Field age = userClass.getDeclaredField("age");
        Field height = userClass.getDeclaredField("height");
        // 直接往内存地址写数据
        unsafe.putObject(user, unsafe.objectFieldOffset(name), "midified-name");
        unsafe.putLong(user, unsafe.objectFieldOffset(id), 100l);
        unsafe.putInt(user, unsafe.objectFieldOffset(age), 101);
        unsafe.putDouble(user, unsafe.objectFieldOffset(height), 100.1);

        System.out.println(user);// 打印midified-name,100,101,100.1

    }
}

结果:

test,1,2,1.72
midified-name,100,101,100.1

6、getLongVolatile/putLongVolatile等等方法

这类方法使用volatile语义去存取数据,我的理解就是各个线程不缓存数据,直接在内存中读取数据;

7、unsafe提供了几种内存屏障

// 在该方法之前的所有读操作,一定在load屏障之前执行完成
public native void loadFence();
// 在该方法之前的所有写操作,一定在store屏障之前执行完成
public native void storeFence();
// 在该方法之前的所有读写操作,一定在full屏障之前执行完成,这个内存屏障相当于上面两个的合体功能
public native void fullFence();

 

 四、unsafe的cas功能底层是怎么保证原子性的

CAS操作的时候,是直接通过( 对象地址 + 对象内部属性偏移量offset )直接定位到要修改的变量在内存的位置,然后在内存级别的比较数据和修改数据。

操作的时候直接根据 o对象地址 + offset偏移量地址,定位到demo属性在内存的位置,然后直接操作内存修改数据。

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_内存地址_05,第5张

由于CPU是不会直接读写主存的,数据读取的时候还是先将数据读取到高速缓存,然后通过高速缓存传递给CPU.写数据的时候也是先高速缓存,然后再将高速缓存的数据写入内存;于是可以得到下面的图形:

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_工具类_06,第6张

 

 多个线程或者多个CPU同时读取demo属性的时候,可能会导致数据不一致。

CAS底层硬件使用锁保证原子性

继承 ConstraintLayout android kotlin 继承无限游戏安全屋,继承 ConstraintLayout android kotlin 继承无限游戏安全屋_数据_07,第7张

 

 

 

(1)首先CPU0要执行CAS操作对变量 i 进行赋值,然后CPU0告诉总线说我要申请单独操作变量 i 的权限,帮我告诉一下CPU1等其它的CPU

(2)总线通知到了CPU1,CPU1告诉总线,好的,我不会操作数据,让CPU0大胆的去操作吧

(3)然后总线告诉CPU0,你可以独占变量i的操作了,其它的cpu表示不会干扰你

(4)然后CPU0从自己的缓存读取 变量 i 的值;然后又根据 (o对象地址 + offset偏移量地址) 直接定位到变量 i 在内存的位置,直接读取变量i在内存的值

(5)接下来的操作就简单了,由于不会有人干扰,直接对比缓存的值和内存的值是否一致就可以了,如果一致,我直接修改,然后刷回主内存;如果不一致,说明我本地的数据不是最新的,需要重新申请CAS操作。

这个就是CAS在底层操作的原理,它底层还是通过加锁来保证原子性的,这个加锁是在硬件级别的,非常轻量级的。

Unsafe中CAS部分的实现
unsafe.cpp,这个就是对应jvm相关的c++实现类了。
在该文件中搜索compareAndSwapInt,此时可以看到对应的JNI方法为Unsafe_CompareAndSwapInt,具体代码如下

UNSAFE_ENTRY(jboolean, Unsafe_CompareAndSwapInt(JNIEnv *env, jobject unsafe, jobject obj, jlong offset, jint e, jint x))
  UnsafeWrapper("Unsafe_CompareAndSwapInt");
  oop p = JNIHandles::resolve(obj); // 查找要指定的对象
  jint* addr = (jint *) index_oop_from_field_offset_long(p, offset); // 获取操作对象偏移量为offset的字段的地址
  return (jint)(Atomic::cmpxchg(x, addr, e)) == e; //执行Atomic类中的cmpxchg
UNSAFE_END

可以看到最后会调用到Atomic::cmpxchg里面的函数,这个根据不同操作系统和不同CPU会有不同的实现,比如linux_64x的,对应类就是hotspot\src\os_cpu\linux_x86\vm\atomic_linux_x86.inline.hpp, 而windows_64x的,对应类就是hotspot\src\os_cpu\windows_x86\vm\atomic_windows_x86.inline.hpp。这里我们以linux_64x的为例,查看Atomic::cmpxchg的实现,atomic_linux_x86.inline.hpp。

inline jint     Atomic::cmpxchg    (jint     exchange_value, volatile jint*     dest, jint     compare_value) {
  int mp = os::is_MP();
  __asm__ volatile (LOCK_IF_MP(%4) "cmpxchgl %1,(%3)"
                    : "=a" (exchange_value)
                    : "r" (exchange_value), "a" (compare_value), "r" (dest), "r" (mp)
                    : "cc", "memory");
  return exchange_value;

 

 

os::is_MP():判断当前系统是否为多核系统,如果是就给总线加锁,所以同一芯片上的其他处理器就暂时不能通过总线访问内存,保证了该指令在多处理器环境下的原子性。

LOCK_IF_MP(mp):LOCK_IF_MP 是一个宏定义,

宏定义用"cmp 1f, " #mp "检查核心是否为单核:

  • 是:跳到cmpxchgl %1,(%3),执行CPU指令1f
  • 不是:则跳到lock前先通过LOCK_IF_MP给总线上锁,令物理处理器的其他核心不能通过总线访存,保证指令操作的原子性。

锁总线根据当前操作系统是否为多核处理器,来决定是否为cmpxchg指令添加lock前缀。如果有lock前缀的话,则会根据CPU不同会采用锁cache line或者

四、JDK或开源框架中使用

的方式,来实现缓存一致性。

 

五、源码

LockSupport中park阻塞,和unpark解除阻塞。
concurrent中中的cas调用。

//下面是sun.misc.Unsafe.java类源码 package sun.misc; import java.lang.reflect.Field; /*** * This class should provide access to low-level operations and its * use should be limited to trusted code. Fields can be accessed using * memory addresses, with undefined behaviour occurring if invalid memory * addresses are given. * 这个类提供了一个更底层的操作并且应该在受信任的代码中使用。可以通过内存地址 * 存取fields,如果给出的内存地址是无效的那么会有一个不确定的运行表现。 * * @author Tom Tromey (tromey@redhat.com) * @author Andrew John Hughes (gnu_andrew@member.fsf.org) */ public class Unsafe { // Singleton class. private static Unsafe unsafe = new Unsafe(); /*** * Private default constructor to prevent creation of an arbitrary * number of instances. * 使用私有默认构造器防止创建多个实例 */ private Unsafe() { } /*** * Retrieve the singleton instance of <code>Unsafe</code>. The calling * method should guard this instance from untrusted code, as it provides * access to low-level operations such as direct memory access. * 获取<code>Unsafe</code>的单例,这个方法调用应该防止在不可信的代码中实例, * 因为unsafe类提供了一个低级别的操作,例如直接内存存取。 * * @throws SecurityException if a security manager exists and prevents * access to the system properties. * 如果安全管理器不存在或者禁止访问系统属性 */ public static Unsafe getUnsafe() { SecurityManager sm = System.getSecurityManager(); if (sm != null) sm.checkPropertiesAccess(); return unsafe; } /*** * Returns the memory address offset of the given static field. * The offset is merely used as a means to access a particular field * in the other methods of this class. The value is unique to the given * field and the same value should be returned on each subsequent call. * 返回指定静态field的内存地址偏移量,在这个类的其他方法中这个值只是被用作一个访问 * 特定field的一个方式。这个值对于 给定的field是唯一的,并且后续对该方法的调用都应该 * 返回相同的值。 * * @param field the field whose offset should be returned. * 需要返回偏移量的field * @return the offset of the given field. * 指定field的偏移量 */ public native long objectFieldOffset(Field field); /*** * Compares the value of the integer field at the specified offset * in the supplied object with the given expected value, and updates * it if they match. The operation of this method should be atomic, * thus providing an uninterruptible way of updating an integer field. * 在obj的offset位置比较integer field和期望的值,如果相同则更新。这个方法 * 的操作应该是原子的,因此提供了一种不可中断的方式更新integer field。 * * @param obj the object containing the field to modify. * 包含要修改field的对象 * @param offset the offset of the integer field within <code>obj</code>. * <code>obj</code>中整型field的偏移量 * @param expect the expected value of the field. * 希望field中存在的值 * @param update the new value of the field if it equals <code>expect</code>. * 如果期望值expect与field的当前值相同,设置filed的值为这个新值 * @return true if the field was changed. * 如果field的值被更改 */ public native boolean compareAndSwapInt(Object obj, long offset, int expect, int update); /*** * Compares the value of the long field at the specified offset * in the supplied object with the given expected value, and updates * it if they match. The operation of this method should be atomic, * thus providing an uninterruptible way of updating a long field. * 在obj的offset位置比较long field和期望的值,如果相同则更新。这个方法 * 的操作应该是原子的,因此提供了一种不可中断的方式更新long field。 * * @param obj the object containing the field to modify. * 包含要修改field的对象 * @param offset the offset of the long field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @param expect the expected value of the field. * 希望field中存在的值 * @param update the new value of the field if it equals <code>expect</code>. * 如果期望值expect与field的当前值相同,设置filed的值为这个新值 * @return true if the field was changed. * 如果field的值被更改 */ public native boolean compareAndSwapLong(Object obj, long offset, long expect, long update); /*** * Compares the value of the object field at the specified offset * in the supplied object with the given expected value, and updates * it if they match. The operation of this method should be atomic, * thus providing an uninterruptible way of updating an object field. * 在obj的offset位置比较object field和期望的值,如果相同则更新。这个方法 * 的操作应该是原子的,因此提供了一种不可中断的方式更新object field。 * * @param obj the object containing the field to modify. * 包含要修改field的对象 * @param offset the offset of the object field within <code>obj</code>. * <code>obj</code>中object型field的偏移量 * @param expect the expected value of the field. * 希望field中存在的值 * @param update the new value of the field if it equals <code>expect</code>. * 如果期望值expect与field的当前值相同,设置filed的值为这个新值 * @return true if the field was changed. * 如果field的值被更改 */ public native boolean compareAndSwapObject(Object obj, long offset, Object expect, Object update); /*** * Sets the value of the integer field at the specified offset in the * supplied object to the given value. This is an ordered or lazy * version of <code>putIntVolatile(Object,long,int)</code>, which * doesn't guarantee the immediate visibility of the change to other * threads. It is only really useful where the integer field is * <code>volatile</code>, and is thus expected to change unexpectedly. * 设置obj对象中offset偏移地址对应的整型field的值为指定值。这是一个有序或者 * 有延迟的<code>putIntVolatile</cdoe>方法,并且不保证值的改变被其他线程立 * 即看到。只有在field被<code>volatile</code>修饰并且期望被意外修改的时候 * 使用才有用。 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the integer field within <code>obj</code>. * <code>obj</code>中整型field的偏移量 * @param value the new value of the field. * field将被设置的新值 * @see #putIntVolatile(Object,long,int) */ public native void putOrderedInt(Object obj, long offset, int value); /*** * Sets the value of the long field at the specified offset in the * supplied object to the given value. This is an ordered or lazy * version of <code>putLongVolatile(Object,long,long)</code>, which * doesn't guarantee the immediate visibility of the change to other * threads. It is only really useful where the long field is * <code>volatile</code>, and is thus expected to change unexpectedly. * 设置obj对象中offset偏移地址对应的long型field的值为指定值。这是一个有序或者 * 有延迟的<code>putLongVolatile</cdoe>方法,并且不保证值的改变被其他线程立 * 即看到。只有在field被<code>volatile</code>修饰并且期望被意外修改的时候 * 使用才有用。 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the long field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @param value the new value of the field. * field将被设置的新值 * @see #putLongVolatile(Object,long,long) */ public native void putOrderedLong(Object obj, long offset, long value); /*** * Sets the value of the object field at the specified offset in the * supplied object to the given value. This is an ordered or lazy * version of <code>putObjectVolatile(Object,long,Object)</code>, which * doesn't guarantee the immediate visibility of the change to other * threads. It is only really useful where the object field is * <code>volatile</code>, and is thus expected to change unexpectedly. * 设置obj对象中offset偏移地址对应的object型field的值为指定值。这是一个有序或者 * 有延迟的<code>putObjectVolatile</cdoe>方法,并且不保证值的改变被其他线程立 * 即看到。只有在field被<code>volatile</code>修饰并且期望被意外修改的时候 * 使用才有用。 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the object field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @param value the new value of the field. * field将被设置的新值 */ public native void putOrderedObject(Object obj, long offset, Object value); /*** * Sets the value of the integer field at the specified offset in the * supplied object to the given value, with volatile store semantics. * 设置obj对象中offset偏移地址对应的整型field的值为指定值。支持volatile store语义 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the integer field within <code>obj</code>. * <code>obj</code>中整型field的偏移量 * @param value the new value of the field. * field将被设置的新值 */ public native void putIntVolatile(Object obj, long offset, int value); /*** * Retrieves the value of the integer field at the specified offset in the * supplied object with volatile load semantics. * 获取obj对象中offset偏移地址对应的整型field的值,支持volatile load语义。 * * @param obj the object containing the field to read. * 包含需要去读取的field的对象 * @param offset the offset of the integer field within <code>obj</code>. * <code>obj</code>中整型field的偏移量 */ public native int getIntVolatile(Object obj, long offset); /*** * Sets the value of the long field at the specified offset in the * supplied object to the given value, with volatile store semantics. * 设置obj对象中offset偏移地址对应的long型field的值为指定值。支持volatile store语义 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the long field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @param value the new value of the field. * field将被设置的新值 * @see #putLong(Object,long,long) */ public native void putLongVolatile(Object obj, long offset, long value); /*** * Sets the value of the long field at the specified offset in the * supplied object to the given value. * 设置obj对象中offset偏移地址对应的long型field的值为指定值。 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the long field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @param value the new value of the field. * field将被设置的新值 * @see #putLongVolatile(Object,long,long) */ public native void putLong(Object obj, long offset, long value); /*** * Retrieves the value of the long field at the specified offset in the * supplied object with volatile load semantics. * 获取obj对象中offset偏移地址对应的long型field的值,支持volatile load语义。 * * @param obj the object containing the field to read. * 包含需要去读取的field的对象 * @param offset the offset of the long field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @see #getLong(Object,long) */ public native long getLongVolatile(Object obj, long offset); /*** * Retrieves the value of the long field at the specified offset in the * supplied object. * 获取obj对象中offset偏移地址对应的long型field的值 * * @param obj the object containing the field to read. * 包含需要去读取的field的对象 * @param offset the offset of the long field within <code>obj</code>. * <code>obj</code>中long型field的偏移量 * @see #getLongVolatile(Object,long) */ public native long getLong(Object obj, long offset); /*** * Sets the value of the object field at the specified offset in the * supplied object to the given value, with volatile store semantics. * 设置obj对象中offset偏移地址对应的object型field的值为指定值。支持volatile store语义 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the object field within <code>obj</code>. * <code>obj</code>中object型field的偏移量 * @param value the new value of the field. * field将被设置的新值 * @see #putObject(Object,long,Object) */ public native void putObjectVolatile(Object obj, long offset, Object value); /*** * Sets the value of the object field at the specified offset in the * supplied object to the given value. * 设置obj对象中offset偏移地址对应的object型field的值为指定值。 * * @param obj the object containing the field to modify. * 包含需要修改field的对象 * @param offset the offset of the object field within <code>obj</code>. * <code>obj</code>中object型field的偏移量 * @param value the new value of the field. * field将被设置的新值 * @see #putObjectVolatile(Object,long,Object) */ public native void putObject(Object obj, long offset, Object value); /*** * Retrieves the value of the object field at the specified offset in the * supplied object with volatile load semantics. * 获取obj对象中offset偏移地址对应的object型field的值,支持volatile load语义。 * * @param obj the object containing the field to read. * 包含需要去读取的field的对象 * @param offset the offset of the object field within <code>obj</code>. * <code>obj</code>中object型field的偏移量 */ public native Object getObjectVolatile(Object obj, long offset); /*** * Returns the offset of the first element for a given array class. * To access elements of the array class, this value may be used along with * with that returned by * <a href="#arrayIndexScale"><code>arrayIndexScale</code></a>, * if non-zero. * 获取给定数组中第一个元素的偏移地址。 * 为了存取数组中的元素,这个偏移地址与<a href="#arrayIndexScale"><code>arrayIndexScale * </code></a>方法的非0返回值一起被使用。 * @param arrayClass the class for which the first element's address should * be obtained. * 第一个元素地址被获取的class * @return the offset of the first element of the array class. * 数组第一个元素 的偏移地址 * @see arrayIndexScale(Class) */ public native int arrayBaseOffset(Class arrayClass); /*** * Returns the scale factor used for addressing elements of the supplied * array class. Where a suitable scale factor can not be returned (e.g. * for primitive types), zero should be returned. The returned value * can be used with * <a href="#arrayBaseOffset"><code>arrayBaseOffset</code></a> * to access elements of the class. * 获取用户给定数组寻址的换算因子.一个合适的换算因子不能返回的时候(例如:基本类型), * 返回0.这个返回值能够与<a href="#arrayBaseOffset"><code>arrayBaseOffset</code> * </a>一起使用去存取这个数组class中的元素 * * @param arrayClass the class whose scale factor should be returned. * @return the scale factor, or zero if not supported for this array class. */ public native int arrayIndexScale(Class arrayClass); /*** * Releases the block on a thread created by * <a href="#park"><code>park</code></a>. This method can also be used * to terminate a blockage caused by a prior call to <code>park</code>. * This operation is unsafe, as the thread must be guaranteed to be * live. This is true of Java, but not native code. * 释放被<a href="#park"><code>park</code></a>创建的在一个线程上的阻塞.这个 * 方法也可以被使用来终止一个先前调用<code>park</code>导致的阻塞. * 这个操作操作时不安全的,因此线程必须保证是活的.这是java代码不是native代码。 * @param thread the thread to unblock. * 要解除阻塞的线程 */ public native void unpark(Thread thread); /*** * Blocks the thread until a matching * <a href="#unpark"><code>unpark</code></a> occurs, the thread is * interrupted or the optional timeout expires. If an <code>unpark</code> * call has already occurred, this also counts. A timeout value of zero * is defined as no timeout. When <code>isAbsolute</code> is * <code>true</code>, the timeout is in milliseconds relative to the * epoch. Otherwise, the value is the number of nanoseconds which must * occur before timeout. This call may also return spuriously (i.e. * for no apparent reason). * 阻塞一个线程直到<a href="#unpark"><code>unpark</code></a>出现、线程 * 被中断或者timeout时间到期。如果一个<code>unpark</code>调用已经出现了, * 这里只计数。timeout为0表示永不过期.当<code>isAbsolute</code>为true时, * timeout是相对于新纪元之后的毫秒。否则这个值就是超时前的纳秒数。这个方法执行时 * 也可能不合理地返回(没有具体原因) * * @param isAbsolute true if the timeout is specified in milliseconds from * the epoch. * 如果为true timeout的值是一个相对于新纪元之后的毫秒数 * @param time either the number of nanoseconds to wait, or a time in * milliseconds from the epoch to wait for. * 可以是一个要等待的纳秒数,或者是一个相对于新纪元之后的毫秒数直到 * 到达这个时间点 */ public native void park(boolean isAbsolute, long time); }

Unsafe源码:

六、示例

package com.dxz.unsafe; import java.lang.reflect.Field; import java.util.Arrays; import sun.misc.Unsafe; public class Test3 { private static int byteArrayBaseOffset; public static void main(String[] args) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException { // 通过反射得到theUnsafe对应的Field对象 Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe"); // 设置该Field为可访问 theUnsafe.setAccessible(true); // 通过Field得到该Field对应的具体对象,传入null是因为该Field为static的 Unsafe UNSAFE = (Unsafe) theUnsafe.get(null); System.out.println(UNSAFE); byte[] data = new byte[10]; System.out.println(Arrays.toString(data)); //arrayBaseOffset方法是一个本地方法,可以获取数组第一个元素的偏移地址 byteArrayBaseOffset = UNSAFE.arrayBaseOffset(byte[].class); System.out.println(byteArrayBaseOffset); //putByte直接修改内存数据 UNSAFE.putByte(data, byteArrayBaseOffset, (byte) 1); UNSAFE.putByte(data, byteArrayBaseOffset + 5, (byte) 5); System.out.println(Arrays.toString(data)); } }

下面这个例子演示了简单的修改一个byte[]的数据。

这个例子在eclipse里不能直接编译,要到项目的属性,Java Compiler,Errors/Warnings中Forbidden reference(access rules)中设置为warning。

另外,因为sun.misc.Unsafe包不能直接使用,所有代码里用反射的技巧得到了一个Unsafe的实例。

sun.misc.Unsafe@15db9742
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
16
[1, 0, 0, 0, 0, 5, 0, 0, 0, 0]

运行结果:

 

 参考:

https://mp.weixin.qq.com/s/ch5FxxNnB2C96cfdrvofRQ

 

 


https://www.xamrdz.com/mobile/4s81963951.html

相关文章: