我们知道，在 Android 自定义 View 的时候，需要使用 TypedArray 来获取 XML layout 中的属性值，使用完之后，需要调用 recycle() 方法将 TypedArray 回收。

当这么用的时候感觉是理所当然，可是仔细一想，TypedArray并没有占用IO，线程，它仅仅是一个变量而已，为什么需要 recycle？让GC自己回收不就好了吗？

官方文档解释

以下是来自TypedArray类的官方文档解释。

Container for an array of values that were retrieved with obtainStyledAttributes(AttributeSet, int[], int, int) or obtainAttributes(AttributeSet, int[]). Be sure to call recycle() when done with them. The indices used to retrieve values from this structure correspond to the positions of the attributes given to obtainStyledAttributes.

以下是对recycle()的方法描述。

 /**
     * Recycles the TypedArray, to be re-used by a later caller. After calling
     * this function you must not ever touch the typed array again.
     *
     * @throws RuntimeException if the TypedArray has already been recycled.
     */
    public void recycle() {
        if (mRecycled) {
            throw new RuntimeException(toString() + " recycled twice!");
        }

        mRecycled = true;

        // These may have been set by the client.
        mXml = null;
        mTheme = null;

        mResources.mTypedArrayPool.release(this);
    }

简单翻译下来，就是说：TypedArray是一个存储属性值的数组，使用完之后应该调用recycle()回收,用于后续调用时可复用之。当调用该方法后，不能再操作该变量。至于深层次的原因，文档没说。这就需要我们自己去研究源码了。

使用方法

首先，是 TypedArray 的常规使用方法：

TypedArray array = context.getTheme().obtainStyledAttributes(attrs,
                R.styleable.PieChart,0,0);
try {
    mShowText = array.getBoolean(R.styleable.PieChart_showText,false);
    mTextPos = array.getInteger(R.styleable.PieChart_labelPosition,0);
}finally {
    array.recycle();
}

可见，TypedArray不是我们new出来的，而是调用了 obtainStyledAttributes 方法得到的对象，该方法实现如下：

public TypedArray obtainStyledAttributes(AttributeSet set,
                int[] attrs, int defStyleAttr, int defStyleRes) {
    final int len = attrs.length;
    final TypedArray array = TypedArray.obtain(Resources.this, len);
    // other code .....
    return array;
}

从上面的代码片段得知，TypedArray也不是它实例化的，而是调用了TypedArray的一个静态方法，得到一个实例，再做一些处理，最后返回这个实例。

public class TypedArray {

    static TypedArray obtain(Resources res, int len) {
        final TypedArray attrs = res.mTypedArrayPool.acquire();
        if (attrs != null) {
            attrs.mLength = len;
            attrs.mRecycled = false;

            final int fullLen = len * AssetManager.STYLE_NUM_ENTRIES;
            if (attrs.mData.length >= fullLen) {
                return attrs;
            }

            attrs.mData = new int[fullLen];
            attrs.mIndices = new int[1 + len];
            return attrs;
        }

        return new TypedArray(res,
                new int[len*AssetManager.STYLE_NUM_ENTRIES],
                new int[1+len], len);
    }
    // Other members ......
}

仔细看一下这个方法的实现，该类没有公共的构造函数，只提供静态方法获取实例。在代码片段的第 5 行，很清晰的表达了这个 array 是从一个 array pool的池中获取的。继续追踪，可以看到这是来自Resources的一个成员变量。

 // Pool of TypedArrays targeted to this Resources object.
    final SynchronizedPool<TypedArray> mTypedArrayPool = new SynchronizedPool<>(5);

从名字上可以看出这是一个同步对象池，数量为5.

具体实现类在 android.support.v4包中。

package android.support.v4.util;


public final class Pools {

    //管理对象池的一个接口
    public static interface Pool<T> {

       //从对象池中取出一个对象
        public T acquire();

      //释放一个对象并重新进入线程池
        public boolean release(T instance);
    }
    //私有构造函数
    private Pools() {
        /* do nothing - hiding constructor */
    }

    //一个简单的非同步对象池实现了对象池管理接口
    public static class SimplePool<T> implements Pool<T> {
        private final Object[] mPool;

        private int mPoolSize;

       //创建一个大小为maxPoolSize的对象池实例
        public SimplePool(int maxPoolSize) {
            if (maxPoolSize <= 0) {
                throw new IllegalArgumentException("The max pool size must be > 0");
            }
            mPool = new Object[maxPoolSize];
        }
    //从对象池中取得一个对象，出栈操作
        @Override
        @SuppressWarnings("unchecked")
        public T acquire() {
            if (mPoolSize > 0) {
                final int lastPooledIndex = mPoolSize - 1;
                T instance = (T) mPool[lastPooledIndex];
                mPool[lastPooledIndex] = null;
                mPoolSize--;
                return instance;
            }
            return null;
        }
       //释放对象，相当于入栈操作
        @Override
        public boolean release(T instance) {
            if (isInPool(instance)) {
                throw new IllegalStateException("Already in the pool!");
            }
            if (mPoolSize < mPool.length) {
                mPool[mPoolSize] = instance;
                mPoolSize++;
                return true;
            }
            return false;
        }
    //判断一个对象实例是否在对象池中
        private boolean isInPool(T instance) {
            for (int i = 0; i < mPoolSize; i++) {
                if (mPool[i] == instance) {
                    return true;
                }
            }
            return false;
        }
    }

      //利用对象锁为SimplePool加了同步访问，使之线程安全
    public static class SynchronizedPool<T> extends SimplePool<T> {
        private final Object mLock = new Object();


        public SynchronizedPool(int maxPoolSize) {
            super(maxPoolSize);
        }

        @Override
        public T acquire() {
            synchronized (mLock) {
                return super.acquire();
            }
        }

        @Override
        public boolean release(T element) {
            synchronized (mLock) {
                return super.release(element);
            }
        }
    }
}

从Pool的实现当中可以看到，Pool是一个final类，本身不可变，不允许继承。而内部类SynchronizedPool通过继承SimplePool，并添加对象锁，实现了一个同步的对象池，保证了线程安全，同时也继承了对象池的优点，避免对象重复创建和销毁，减少了系统开销。

结论

  从上述源码可以看到，framework层维护了一个同步栈结构的对象池，从而避免在程序运行期间频繁创建属性值TypedArray对象，维护TypedArray对象池的大小默认为5，使用时记得调用recyle()方法将不用的对象返回至对象池来达到重用的目的。

更确切来讲，TypedArray的使用场景之一，就是上述的自定义View，会随着 Activity的每一次Create而Create，因此，需要系统频繁的创建array，对内存和性能是一个不小的开销，如果不使用池模式，每次都让GC来回收，很可能就会造成OutOfMemory。不得不让人Google程序猿大神们的构思和精妙的设计，也为我们平常编写程序优化性能提供了依据和参考。