C#中设计一个 ListPool 的方案

1、回顾一下有关List的几个知识点。

    点1: 注意理解 Capacity 与 Count 的不同之处。

    点2: 执行 TrimExcess() 方法可将容量设置为 List 中元素的实际数目。

    点3: List的 Capacity (注意理解与 Count 的不同之处)扩充是以 4 的倍数来扩充的。

    点4: 执行完 Clear() 方法后，Capacity 是不会变化的。

List<int> list = new List<int>();
Console.WriteLine(list.Capacity);   // 0
list.Add(1);
Console.WriteLine(list.Capacity);   // 4

2、ListPool方案:

using System;
using System.Collections.Generic;

public interface IListPoolBase
{
    void DoClear(int nowSeconds);
}

public class ListPoolItem<T> : IListPoolBase
{
    static int intervalTime = 30;  //清理池子的时间间隔(单位 : 秒)
    public List<List<T>> pool;      //用List而不用Stack是因为在回收的时候，当pool达到上限的时候，要替换到 Capacity 最大的那个，用 Stack 无法自主替换
    public int lastUsedSeconds;

    public ListPoolItem(int initSize)
    {
        lastUsedSeconds = (int)(DateTime.Now.Ticks / TimeSpan.TicksPerSecond);
        pool = new List<List<T>>(initSize);
    }

    //长时间不用，清理一下池子
    public void DoClear(int nowSeconds)
    {
        if (pool.Count > 0)
        {
            int durationNotUse = nowSeconds - lastUsedSeconds;
            if (durationNotUse >= intervalTime)
            {
                pool.Clear();
            }
        }
    }

    public void Use()
    {
        lastUsedSeconds = (int)(DateTime.Now.Ticks / TimeSpan.TicksPerSecond);
    }
}

public static class ListPool<T>
{
    public static int maxPoolSize = 4;
    static ListPoolItem<T> poolItem;

    static ListPool()
    {
        poolItem = new ListPoolItem<T>(maxPoolSize);
        ListPoolManager.Register(poolItem);
    }

    public static List<T> Get()
    {
        lock (poolItem)
        {
            poolItem.Use();
            List<List<T>> pool = poolItem.pool;
            int poolSize = pool.Count;
            if (poolSize > 0)
            {
                List<T> list = pool[poolSize - 1];
                pool.RemoveAt(poolSize - 1);
                return list;
            }
            else
            {
                return new List<T>();
            }
        }
    }

    public static void Release(ref List<T> list)
    {
        if (null == list) return;
        lock (poolItem)
        {
            poolItem.Use();
            List<List<T>> pool = poolItem.pool;
            List<T> _list = list;
            list = null;
            if (pool.Contains(_list))
                return;
            _list.Clear();

            //当_List的开辟的容量过大的时候，需要考虑到无用的容量，之所以加这个判断而不是直接清除，是为了避免反复的开辟空间
            if (_list.Capacity >= 4096)
            {
                _list.TrimExcess();
            }

            int poolSize = pool.Count;
            //当pool的容量达到最大的时候，替换掉容量最大的那个
            if (poolSize >= maxPoolSize)
            {
                int replaceIndex = -1;
                int maxCapacity = _list.Capacity;
                for (int i = 0; i < poolSize; ++i)
                {
                    List<T> curList = pool[i];
                    if (curList.Capacity > maxCapacity)
                    {
                        replaceIndex = i;
                        maxCapacity = curList.Capacity;
                    }
                }

                if (replaceIndex >= 0)
                {
                    pool[replaceIndex] = _list;
                }
                return;
            }

            pool.Add(_list);
        }
    }
}

//检测ListPool的使用情况
public static class ListPoolManager
{
    static int _timerMS;
    static int _minTriggerTimeMS = 3000;  //执行检测的时间间隔
    static List<IListPoolBase> listPool = new List<IListPoolBase>();

    public static void Register(IListPoolBase poolItem)
    {
        listPool.Add(poolItem);
    }

    //在主线程中做检测
    public static void DoTracer(int deltaTimeMS)
    {
        _timerMS += deltaTimeMS;
        //降低执行检测的频率
        if (_timerMS < _minTriggerTimeMS)
            return;

        _timerMS = 0;

        int nowSeconds = (int)(DateTime.Now.Ticks / TimeSpan.TicksPerSecond);
        for (int i = 0; i < listPool.Count; ++i)
        {
            listPool[i].DoClear(nowSeconds);
        }
    }
}