VelocityTracker

直譯過來就是速度追蹤的意思，用于追蹤手指滑動過程中的瞬時速度

使用方法如下

VelocityTracker velocityTracker = VelocityTracker.obtain();
//想要追蹤當前速度，將事件加入追蹤器
velocityTracker.addMovement(event);
//調用計算速度代碼, 這個必須要調用
velocityTracker.computeCurrentVelocity(1000);
//分別獲取x軸和y軸方向的1s時間內的平均速度
int xVelocity = (int) velocityTracker.getXVelocity();
int yVelocity = (int) velocityTracker.getYVelocity();
//釋放追蹤器
velocityTracker.recycle();
//重置并回收內存
velocityTracker.clear();

使用起來很簡單，VelocityTracker源碼大多都是native方法，研究了它的緩存機制，涉及以下方法

• static public VelocityTracker obtain()
• public void recycle()

VelocityTracker涉及緩存相關如下

• SynchronizedPool<VelocityTracker> sPool //緩存池變量

//設置緩存池大小為2
private static final SynchronizedPool<VelocityTracker> sPool =
            new SynchronizedPool<VelocityTracker>(2);

static public VelocityTracker obtain() {
      //從緩存池中獲取VelocityTracker對象
       VelocityTracker instance = sPool.acquire();
       return (instance != null) ? instance : new VelocityTracker(null);
}
/**
  * 釋放VelocityTracker歸還緩存池中
  */
public void recycle() {
        if (mStrategy == null) {
            clear();
            sPool.release(this);
        }
}

SynchronizedPool這個類繼承自SimplePool

    public static class SimplePool<T> implements Pool<T> {
        private final Object[] mPool;

        private int mPoolSize;

        /**
         * 創(chuàng)建一個指定大小的緩存池對象
         */
        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() {
            //如果緩存池有對象 ，則直接將末尾的實例返回，同時置空處理，緩存池大小-1
            if (mPoolSize > 0) {
                final int lastPooledIndex = mPoolSize - 1;
                T instance = (T) mPool[lastPooledIndex];
                mPool[lastPooledIndex] = null;
                mPoolSize--;
                return instance;
            }
            return null;
        }

       /**
        *  釋放操作，如果緩存池為空，則將實例加入池中，如果不調用release操作，緩存池當中將不會有實例
        */
        @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;
        }
    }

SynchronizedPool相比于SimplePool不同點在于SynchronizedPool的獲取和釋放操作都是同步加鎖操作
另外如果VelocityTracker中不調用recycle操作，sPool不會起到緩存的作用，因為始終是空的