Unsafe 类的API使用说明

版权声明：
api说明：
Unsafe 类的API说明，功能强大。

版权声明：api示例为CSDN博主「黑夜中的一抹光」的原创文章

Unsafe类通过JNI的方式访问本地的C++实现库从而使java具有了直接操作内存空间的能力，Unsafe提供了硬件级别的原子性操作

api说明

objectFieldOffset()方法用于获取某个字段相对Java对象的“起始地址”的偏移量
unsafe.compareAndSwapInt这个方法，这个方法有四个参数，其中第一个参数为需要改变的对象，第二个为偏移量(即之前求出来的valueOffset的值)，第三个参数为期待的值，第四个为更新后的值

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);
}

api使用示例：

public class UnsafeTest1 {
    private static Unsafe unsafe;
    @Before
    public void before(){
        try {
            // 注意：Unsafe的对象不能直接new,这里通过反射去获取Unsafe里面的私有成员变量theUnsafe
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            unsafe = (Unsafe)field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
     // 获取对象字段或静态属性的内存地址偏移量
    @Test
    public void testGetFieldOffset() throws NoSuchFieldException, IllegalAccessException {
        //获取字段偏移量
        long address = unsafe.objectFieldOffset(People.class.getDeclaredField("name"));
        System.out.println("实例变量name属性的偏移量："+address);

        //获取静态字段偏移量
        long staticAddress = unsafe.staticFieldOffset(People.class.getDeclaredField("info"));
        System.out.println("静态变量info属性的偏移量："+staticAddress);
    }
    // 内存操作，包括内存的分配，释放，复制
    @Test
    public void testMemoryOperate() throws NoSuchFieldException, IllegalAccessException {
        //分配内存
        long address = unsafe.allocateMemory(4);
        System.out.println(address);
        //扩展内存
        long newAddress = unsafe.reallocateMemory(address, 8);
        System.out.println(newAddress);
        //释放内存
        unsafe.freeMemory(newAddress);
    }
    // 通过操作内存从一个给定的java变量获取或设置值
    @Test
    public void testGetAndPutInt() throws NoSuchFieldException, IllegalAccessException {
        People people = new People("liming",16);
        //通过objectFieldOffset方法获取学生年龄在内存中的偏移量
        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("age"));
        System.out.println("获取学生年龄在内存中的偏移量:"+offset);
        //通过操作内存的方式获取学生年龄
        int anInt = unsafe.getInt(people, offset);
        System.out.println("获取学生年龄在内存中的值:"+anInt);
        System.out.println("获取学生年龄值:"+people.getAge());
        //通过操作内存的方式修改学生年龄
        unsafe.putInt(people,offset,30);
        System.out.println("通过unsafe修改后的值:"+people.getAge());
    }

    @Test
    public void testGetAndPutObject() throws NoSuchFieldException, IllegalAccessException {

        People people = new People("liming",16);
        //通过objectFieldOffset方法获取学生姓名在内存中的偏移量
        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("name"));
        //获取对象属性
        System.out.println(unsafe.getObject(people,offset));
        System.out.println(people.getName());
        //修改对象属性
        unsafe.putObject(people,offset,"xiahua");
        System.out.println(people.getName());
    }
    // 通过操作内存从一个内存地址获取或设置值
    @Test
    public void testGetAndPutInt2() throws NoSuchFieldException, IllegalAccessException {
        //通过allocateMemory方法分配一个8具有8个字节的内存空间
        long address = unsafe.allocateMemory(8);

        //给指定的内存空间写入一个整型值
        unsafe.putInt(address,60);
        //获取内存空间的值
        System.out.println(unsafe.getInt(address));

        //重新分配内存，扩大到16字节
        final long newAddress = unsafe.reallocateMemory(address, 16);
        unsafe.putInt(newAddress,100);
        System.out.println(unsafe.getInt(newAddress));

        //回收分配的内存空间
        unsafe.freeMemory(newAddress);
    }
    // 通过操作内存从一个给定的变量获取或设置一个具有volatile语义的值
    @Test
    public void testGetAndPutIntVolatile() throws NoSuchFieldException, IllegalAccessException {
        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("age"));

        //设置学生的年龄，使用volatile语义，设置后立马更新到内存对其他线程可见。
        unsafe.putIntVolatile(People.class,offset,32);
        System.out.println(unsafe.getIntVolatile(People.class,offset));
    }
    // 惰性设值，设值后内存不能保证立即对其他线程可见，并且变量和后序内存可以重排序
    @Test
    public void testPutIntVolatileLazy() throws NoSuchFieldException, IllegalAccessException {
        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("age"));

        unsafe.putOrderedInt(People.class,offset,100);
        System.out.println(unsafe.getIntVolatile(People.class,offset));
    }
    // 通过操作内存获取或设置数组元素值
    @Test
    public void testArrayOperate() throws NoSuchFieldException, IllegalAccessException {
        int[] array = new int[]{1,5,8,9,6,4,7};

        //获取数组中第一个元素在内存的偏移地址
        int offset = unsafe.arrayBaseOffset(array.getClass());
        //获取数组增量元素在内存中的地址
        int indexScale = unsafe.arrayIndexScale(array.getClass());

        //通过操作内存地址获取数组的第一个元素
        System.out.println(unsafe.getInt(array,offset));
        //通过操作内存修改数组的第一个元素
        unsafe.putInt(array,offset,3);
        System.out.println(unsafe.getInt(array,offset));
        //通过操作内存获取数组的第三个元素，arrayBaseOffset和arrayIndexScale共同使用，就可以获得任意一个数组元素在内存的地址
        System.out.println(unsafe.getInt(array,indexScale*2+offset));

        //通过循环遍历数组元素
        for (int i = 0; i < array.length; i++) {
            System.out.print(unsafe.getInt(array,i*indexScale+offset) + " ");
        }
    }

    @Test
    public void testGetAndPutAddress() throws NoSuchFieldException, IllegalAccessException {
        //通过allocateMemory方法分配一个8具有8个字节的内存空间
        long address = unsafe.allocateMemory(8);

        //给这个内存中存放一个本地指针
        unsafe.putAddress(address,200);
        //获取指定内存地址的指针
        System.out.println(unsafe.getAddress(address));
        //打印通过putAddress存放的本地指针的大小
        System.out.println(unsafe.addressSize());
        //打印内存页面的大小，通常为4k,即4096   //关于内存页面不了解的可以看下操作系统相关的知识
        System.out.println(unsafe.pageSize());
        //释放内存
        unsafe.freeMemory(address);
    }
    // 硬件级别的CAS操作
    @Test
    public void testCAS() throws NoSuchFieldException, IllegalAccessException {
        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("age"));

        unsafe.putInt(People.class,offset,25);
        System.out.println(unsafe.getInt(People.class,offset));
        //通过Unsafe提供的硬件级别的原子操作 CAS算法更新学生的年龄
        unsafe.compareAndSwapInt(People.class,offset,24,35);
        System.out.println(unsafe.getInt(People.class,offset));

        unsafe.compareAndSwapInt(People.class,offset,25,35);
        System.out.println(unsafe.getInt(People.class,offset));
    }
    // 线程的挂起与恢复
    @Test
    public void testParkAndUnPark() throws NoSuchFieldException, IllegalAccessException {
        //写一个线程执行一个任务
        Thread thread = new Thread(() -> System.out.println("hello"));
        thread.start();
        //线程恢复
        unsafe.unpark(Thread.currentThread());  //如果不加这句，线程或一直处于阻塞状态
        //线程挂起，直到unpark调用或者打断或者超时，线程恢复。
        //isAbsolute设置是否为绝对时间，如果为true，则超时时间的单位为毫秒
        //isAbsolute为false，time设置为0，就是一直阻塞，如果time不为0，则超时时间的单位为纳秒
        unsafe.park(false,0);
    }
    // 从一个变量获取值并让它自动增加给定的值
    @Test
    public void testGetAndAddInt() throws NoSuchFieldException, IllegalAccessException {
        final Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        Unsafe unsafe = (Unsafe) theUnsafe.get(null);

        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("age"));

        unsafe.putInt(People.class,offset,30);
        System.out.println(unsafe.getAndAddInt(People.class,offset,3));
        System.out.println(unsafe.getInt(People.class,offset));
    }
    // 从一个变量获取值并设置成另一个值
    @Test
    public void testGetAndSetInt() throws NoSuchFieldException, IllegalAccessException {
        final Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
        theUnsafe.setAccessible(true);
        Unsafe unsafe = (Unsafe) theUnsafe.get(null);

        long offset = unsafe.objectFieldOffset(People.class.getDeclaredField("age"));

        unsafe.putInt(People.class,offset,30);
        System.out.println(unsafe.getAndSetInt(People.class,offset,32));
        System.out.println(unsafe.getInt(People.class,offset));
    }
}

//people类
public class People {
    private String name;
    private int age;
    public static String info;

    static {
        info = "hello world";
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public People() {
    }
}