小巧的对象池Pools

        AndroidX的核心库中有一个util工具包，里面有一个用于创建对象池的帮助类：Pools。简短的一百行代码呈现了一个标准对象池的实现。

1、Pool<T>接口

        从源码中看见官方标准的对象池接口定义Pool<T>。

    /**
     * 用于管理对象池的接口。
     *
     * @param <T> The pooled type.
     */
    public interface Pool<T> {
    
        /**
         * @return 返回对象池中的一个实例，或者null.
         */
        @Nullable
        T acquire();
        
        /**
         * 将实例释放到池中。
         *
         * @param instance 要释放的实例。
         * @return 是否将实例放入池中：true放入，false未放入。
         *
         * @throws IllegalStateException 如果实例已经在池中抛出异常。
         */
        boolean release(@NonNull T instance);
        
    }

2、实现对象池

        基于上面定义的Pool接口，实现对象池，这对于程序员来说是基本功。看看框架的是怎么实现的。

2.1、SimplePool

        最简单的对象池实现SimplePool如下：构造方法中传入对象池大小maxPoolSize，用来初始化固定大小的数组mPool，数组用来存放对象。

    /**
     * Simple (non-synchronized) pool of objects.
     *
     * @param <T> The pooled type.
     */
    public static class SimplePool<T> implements Pool<T> {
        private final Object[] mPool;
        private int mPoolSize;
        
        /**
         * Creates a new instance.
         *
         * @param maxPoolSize The max pool size.
         *
         * @throws IllegalArgumentException If the max pool size is less than zero.
         */
        public SimplePool(int maxPoolSize) {
            if (maxPoolSize <= 0) {
                throw new IllegalArgumentException("The max pool size must be > 0");
            }
            mPool = new Object[maxPoolSize];
        }
        
        //从对象池中取出对象复用，如果没有则返回null
        @Override
        public T acquire() {
            if (mPoolSize > 0) {
                final int lastPooledIndex = mPoolSize - 1;
                T instance = (T) mPool[lastPooledIndex];
                mPool[lastPooledIndex] = null;
                mPoolSize--;
                return instance;
            }
            return null;
        }
        
        //简单的数组数据结构+1
        @Override
        public boolean release(@NonNull T instance) {
            if (isInPool(instance)) {
                throw new IllegalStateException("Already in the pool!");
            }
            if (mPoolSize < mPool.length) {
                mPool[mPoolSize] = instance;
                mPoolSize++;
                return true;
            }
            return false;
        }
        
        //遍历instance对象是否已经在数组池mPool中
        private boolean isInPool(@NonNull T instance) {
            for (int i = 0; i < mPoolSize; i++) {
                if (mPool[i] == instance) {
                    return true;
                }
            }
            return false;
        }
    }

2.2、SynchronizedPool

        上面的SimplePool对象池并非线程安全，多线程情况下可能会出现溢出或者重复使用同一个对象。如何修改呢？最简答快速的完善是继承SimplePool给acquire()和release(T element)方法添加同步锁synchronized，即可实现同步对象池SynchronizedPool：

    /**
     * Synchronized) pool of objects.
     *
     * @param <T> The pooled type.
     */
    public static class SynchronizedPool<T> extends SimplePool<T> {
        //创建一个对象锁
        private final Object mLock = new Object();
        
        /**
         * Creates a new instance.
         *
         * @param maxPoolSize The max pool size.
         *
         * @throws IllegalArgumentException If the max pool size is less than zero.
         */
        public SynchronizedPool(int maxPoolSize) {
            super(maxPoolSize);
        }
        
        //从对象池中获取对象的时候加锁
        @Override
        public T acquire() {
            synchronized (mLock) {
                return super.acquire();
            }
        }
        
        //释放对象到对象池中也加锁，避免多线程写而造成数组溢出
        @Override
        public boolean release(@NonNull T element) {
            synchronized (mLock) {
                return super.release(element);
            }
        }
    }

参考资料：

        Android Developers > Docs > Reference > Pools

        Android Developers > Docs > Reference > Pools.SimplePool

        Android Developers > Docs > Reference > Pools.SynchronizedPool