多线程进阶二 Unsafe 源码

java中的Unsafe类
java不能直接访问操作系统底层，而是通过本地方法来访问。Unsafe类提供了硬件级别的原子操作，主要提供了以下功能：

1、通过Unsafe类可以分配内存，可以释放内存；

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

public native long allocateMemory(long l);public native long reallocateMemory(long l, long l1);public native void freeMemory(long l);

字段的定位：

JAVA中对象的字段的定位可能通过staticFieldOffset方法实现，该方法返回给定field的内存地址偏移量，这个值对于给定的filed是唯一的且是固定不变的。

getIntVolatile方法获取对象中offset偏移地址对应的整型field的值,支持volatile load语义。

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配合使用，可以定位数组中每个元素在内存中的位置。

 private static final Unsafe theUnsafe = new Unsafe();  public static final int INVALID_FIELD_OFFSET = -1;  public static final int ARRAY_BOOLEAN_BASE_OFFSET = theUnsafe.arrayBaseOffset([Z.class);  public static final int ARRAY_BYTE_BASE_OFFSET = theUnsafe.arrayBaseOffset([B.class);  public static final int ARRAY_SHORT_BASE_OFFSET = theUnsafe.arrayBaseOffset([S.class);  public static final int ARRAY_CHAR_BASE_OFFSET = theUnsafe.arrayBaseOffset([C.class);  public static final int ARRAY_INT_BASE_OFFSET = theUnsafe.arrayBaseOffset([I.class);  public static final int ARRAY_LONG_BASE_OFFSET = theUnsafe.arrayBaseOffset([J.class);  public static final int ARRAY_FLOAT_BASE_OFFSET = theUnsafe.arrayBaseOffset([F.class);  public static final int ARRAY_DOUBLE_BASE_OFFSET = theUnsafe.arrayBaseOffset([D.class);  public static final int ARRAY_OBJECT_BASE_OFFSET = theUnsafe.arrayBaseOffset([Ljava.lang.Object.class);  public static final int ARRAY_BOOLEAN_INDEX_SCALE = theUnsafe.arrayIndexScale([Z.class);  public static final int ARRAY_BYTE_INDEX_SCALE = theUnsafe.arrayIndexScale([B.class);  public static final int ARRAY_SHORT_INDEX_SCALE = theUnsafe.arrayIndexScale([S.class);  public static final int ARRAY_CHAR_INDEX_SCALE = theUnsafe.arrayIndexScale([C.class);  public static final int ARRAY_INT_INDEX_SCALE = theUnsafe.arrayIndexScale([I.class);  public static final int ARRAY_LONG_INDEX_SCALE = theUnsafe.arrayIndexScale([J.class);  public static final int ARRAY_FLOAT_INDEX_SCALE = theUnsafe.arrayIndexScale([F.class);  public static final int ARRAY_DOUBLE_INDEX_SCALE = theUnsafe.arrayIndexScale([D.class);  public static final int ARRAY_OBJECT_INDEX_SCALE = theUnsafe.arrayIndexScale([Ljava.lang.Object.class);

4、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操作有3个操作数，内存值M，预期值E，新值U，如果M==E，则将内存值修改为B，否则啥都不做。
首先介绍一下什么是Compare And Swap(CAS)？简单的说就是比较并交换。

CAS 操作包含三个操作数 —— 内存位置（V）、预期原值（A）和新值(B)。如果内存位置的值与预期原值相匹配，那么处理器会自动将该位置值更新为新值。否则，处理器不做任何操作。无论哪种情况，它都会在 CAS 指令之前返回该位置的值。CAS 有效地说明了“我认为位置 V 应该包含值 A；如果包含该值，则将 B 放到这个位置；否则，不要更改该位置，只告诉我这个位置现在的值即可。” Java并发包(java.util.concurrent)中大量使用了CAS操作,涉及到并发的地方都调用了sun.misc.Unsafe类方法进行CAS操作。

在看一下volatile, Volatile修饰的成员变量在每次被线程访问时，都强迫从共享内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的值是相同的，更简单一点理解就是volatile修饰的变量值发生变化时对于另外的线程是可见的。

如何正确使用volatile可以参考下面这篇文章：

http://www.ibm.com/developerworks/cn/java/j-jtp06197.html Java 理论与实践: 正确使用 Volatile 变量

下面来看看java中具体的CAS操作类sun.misc.Unsafe。Unsafe类提供了硬件级别的原子操作，Java无法直接访问到操作系统底层（如系统硬件等)，为此Java使用native方法来扩展Java程序的功能。具体实现使用c++,详见文件sun.misc.natUnsafe.cc();sun.misc包的源代码可以在这里找到：

http://www.oschina.net/code/explore/gcc-4.5.2/libjava/sun/misc

//下面是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 ([e-mail]) * @author Andrew John Hughes ([e-mail]) */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);}

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

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

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

import java.lang.reflect.Field;import java.util.Arrays;import sun.misc.Unsafe;public class Test {    private static int byteArrayBaseOffset;    public static void main(String[] args) throws SecurityException,            NoSuchFieldException, IllegalArgumentException,            IllegalAccessException {        Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");        theUnsafe.setAccessible(true);        Unsafe UNSAFE = (Unsafe) theUnsafe.get(null);        System.out.println(UNSAFE);        byte[] data = new byte[10];        System.out.println(Arrays.toString(data));        byteArrayBaseOffset = UNSAFE.arrayBaseOffset(byte[].class);        System.out.println(byteArrayBaseOffset);        UNSAFE.putByte(data, byteArrayBaseOffset, (byte) 1);        UNSAFE.putByte(data, byteArrayBaseOffset + 5, (byte) 5);        System.out.println(Arrays.toString(data));    }}

运行结果：

sun.misc.Unsafe@6af62373
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
24
[1, 0, 0, 0, 0, 5, 0, 0, 0, 0]

package com.lzzl.thread16;public class Person {    int age;    String name;    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    @Override    public String toString() {        return "Person [age=" + age + ", name=" + name + "]";    }}

import java.lang.reflect.Field;import java.util.Arrays;import sun.misc.Unsafe;public class Run1 {    @SuppressWarnings("restriction")    public static void main(String[] args) throws Exception {        Run1 r = new Run1();        r.test();        r.test1();    }    @SuppressWarnings("restriction")    private void test() throws Exception {        System.out.println("---------------------test-------------beg----------------");        Person p = new Person();        p.setAge(11);        p.setName("丽丽");        Person[] parr = new Person[5];        Field theunsafe = Unsafe.class.getDeclaredField("theUnsafe");        theunsafe.setAccessible(true);        Unsafe unsafe = (Unsafe) theunsafe.get(null);        int beg = unsafe.arrayBaseOffset(parr.getClass());        System.out.println(Arrays.toString(parr));        System.out.println("beg:"+beg);        unsafe.putObject(parr, beg, p);        System.out.println(Arrays.toString(parr));        System.out.println(unsafe.arrayIndexScale(Person[].class));        System.out.println("---------------------test-------------end----------------");    }    private void test1() throws Exception{        System.out.println("---------------------test1-------------beg----------------");        int[] arrint = new int[5];        Field theunsafe = Unsafe.class.getDeclaredField("theUnsafe");        theunsafe.setAccessible(true);        Unsafe unsafe = (Unsafe) theunsafe.get(null);        int beg = unsafe.arrayBaseOffset(int[].class);        System.out.println(Arrays.toString(arrint));        System.out.println("beg:"+beg);        unsafe.putIntVolatile(arrint, beg, 1);        unsafe.putIntVolatile(arrint, beg+4, 2);        unsafe.putIntVolatile(arrint, beg+8, 3);        System.out.println(Arrays.toString(arrint));        System.out.println("---------------------test1-------------end----------------");    }}

运行结果：
———————test————-beg—————-
[null, null, null, null, null]
beg:16
[Person [age=11, name=丽丽], null, null, null, null]
4
———————test————-end—————-
———————test1————-beg—————-
[0, 0, 0, 0, 0]
beg:16
[1, 2, 3, 0, 0]
———————test1————-end—————-