在很多项目中，尤其是服务端，我们需要临时缓存一些数据，对于完整的我就不说了。主要的保持方法有：

1.大型数据库

2.缓存组件

3.文件（按照自己定义的格式存储）

4.一些缓存数据库（sqlte,h2,mongdb,redis等）

5.自定义的缓存方法。

这里我主要说说第5种方法，自定义类

首先我们定义一个泛型模板，用于存储真正的数据。

public class BaseBuffer<T>
    {

/// <summary>
        /// 真实数据对象
        /// </summary>
        public T Data { get; set; }

/// <summary>
        /// 使用的时间
        /// </summary>
        public DateTime DateTime { get; set; }

//缓存丢失清理数据
        public virtual void Dispose()
        {

}

/// <summary>
        /// 重置
        /// </summary>
        public virtual void Reset()
        {

}
    }

类似这样一个结构。

在存储时，我们需要一个类来管理，也就是缓存池的对象。

public class BufferPool<T>
    {
        /// <summary>
        /// 缓存结构
        /// </summary>
        protected Stack<BaseBuffer<T>> buffers = new Stack<BaseBuffer<T>>(100);
        private readonly object lock_obj = new object();
        private int useNum = 0;//当前缓存使用
        private volatile bool isRun = false;//已经启动运算
        private int[] record = null;//记录
        protected int waitTime = 20;//计算的分钟时间
        private int index = 0;//索引计算
        private int  maxNum = 0;//最近一段时间最大使用
        private int havNum = 0;//已经创建的缓存
        private int minWaitTime = 100;//
        private int maxBufferNum = int.MaxValue;
        
        public BufferPool()
        {
            record = new int[waitTime];

}

/// <summary>
        /// 设置运行的最大值
        /// </summary>
        public int MaxBufferSize { get { return maxBufferNum; } set { maxBufferNum = value; } }
        /// <summary>
        /// 初始化缓存对象
        /// </summary>
        /// <param name="initNum"></param>
        public void InitPool(int initNum = 10)
        {
            if (initNum > 0)
            {
                for (int i = 0; i < initNum; i++)
                {
                    buffers.Push(Create());
                }
            }
        }

/// <summary>
        /// 刷新
        /// </summary>
        private void  RefreshCount()
        {
            if(isRun)
            {
                return;
            }
            isRun = true;
            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(60000);//1分钟
                //
                record[index] = useNum;
                index++;
                if(index%waitTime==0)
                {
                    //监测waitTime分钟内没有使用的
                    lock (lock_obj)
                    {
                        var bufs= buffers.ToArray();
                        buffers.Clear();
                        foreach(var buf in bufs)
                        {
                            if((DateTime.Now-buf.DateTime).TotalMinutes<waitTime)
                            {
                                buffers.Push(buf);
                            }

else
                            {
                                buf.Dispose();
                            }
                        }
                        //
                        int sum = 0;
                        int avg = 0;
                        for(int i=0;i<record.Length;i++)
                        {
                            sum += record[i];
                        }
                        //计算时间内的平均值
                        avg = sum / record.Length;
                        //如果当前使用小于平均值，则最多只保留平均值个数
                        //说明当前使用可能在下降
                        if(useNum<avg&&buffers.Count>avg)
                        {
                            int num = buffers.Count - avg;
                            for (int i=0;i<num;i++)
                            {
                                var buf=  buffers.Pop();
                                buf.Dispose();//不使用时释放
                            }
                        }
                       if(useNum>avg&&useNum>maxNum&&buffers.Count> maxNum)
                        {
                            //当前使用大于平均值，并且大于最近的最大值，说明再继续增加可能
                            //那就以最大缓存值为准
                            int num = buffers.Count - avg;
                            for (int i = 0; i < num; i++)
                            {
                                var buf = buffers.Pop();
                                buf.Dispose();//不使用时释放
                            }
                        }

}
                }
                isRun = false;
            });
        }
        /// <summary>
        /// 创建缓存对象
        /// </summary>
        /// <returns></returns>
        public virtual BaseBuffer<T> Create()
        {
            Interlocked.Increment(ref havNum);
            return new BaseBuffer<T>();
        }

/// <summary>
        /// 获取缓存对象
        /// </summary>
        /// <returns></returns>
        public BaseBuffer<T> GetBuffer()
        {
            lock (lock_obj)
            {
                try
                {
                    if (useNum < havNum)
                    {
                        //正在使用的小于已经创建的缓存
                        BaseBuffer<T> cache = buffers.Pop();
                        cache.DateTime = DateTime.Now;
                        useNum++;
                        this.RefreshCount();
                        return cache;
                    }
                    else if(havNum<maxBufferNum)
                    {
                        return Create();
                    }
                    else
                    {
                        return null;
                    }
                }
                catch
                {
                    return Create();
                }
            }
        }

/// <summary>
        /// 超时获取数据
        /// </summary>
        /// <param name="waitTime">等待时间(毫秒)</param>
        /// <param name="buffer">获取的buffer对象</param>
        /// <returns>获取成功</returns>
         public bool TryGetBuffer(int waitTime=0, out  BaseBuffer<T>  buffer)
        {
            buffer = null;
            if(waitTime<1)
            {
                if((buffer = GetBuffer())==null)
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            else
            {
                int sleepTime = 0;
                int sum = 0;
                if (waitTime < minWaitTime)
                {
                    sleepTime = waitTime;
                }
                else
                {
                    sleepTime = 100;
                }
                while ((buffer = GetBuffer()) == null)
                {
                    Thread.Sleep(sleepTime);
                    sum += sleepTime;
                    if (sum > waitTime)
                    {
                        break;
                    }
                }
                if(buffer==null)
                {
                    //最后再获取一次
                    buffer = GetBuffer();
                    if(buffer==null)
                    {
                        return false;
                    }
                    else
                    {
                        return true;
                    }
                }
                else
                {
                    return true;
                }
            }
        }

/// <summary>
        /// 获取一组缓存
        /// </summary>
        /// <param name="num"></param>
        /// <returns></returns>
        public virtual List<BaseBuffer<T>> GetCacheBuffers(int num)
        {
            List<BaseBuffer<T>> list = new List<BaseBuffer<T>>(num);
            for(int i=0;i<num;i++)
            {
                list.Add(GetBuffer());
            }
            return list;
        }
        /// <summary>
        /// 缓存释放
        /// </summary>
        /// <param name="client"></param>
        public void Free(BaseBuffer<T> client)
        {
            lock (lock_obj)
            {
                useNum--;
                buffers.Push(client);
            }
        }
    }

一看就懂，不懂就完全弄到你的VS2017上面看看。

其实主要是回收缓存对象。获取对象，获取时提供了2个方法，直接获取以及有时间等待的。

刷新统计方法主要是用来动态平衡的。以20分钟为粒度。计算平均值，动态释放一些不需要的。

为什么使用的是Stack？

因为它是先进后出，这样如果有buffer一段时间没有使用，则它一直在尾部，例如：有100个buffer,一段时间只有了80个，另外20个就一直不会使用，这样在启动线程监测buffer时，就知道你有20个一直没有用，于是这20个算超时没有使用的，直接释放。

另外一类自定义缓存实现，推荐博文,我也集成到了我的项目模板中。

我自己的实现已经传到git,地址与前面博文提供的地址一样，项目名称是CacheBuffer

https://www.cnblogs.com/ylsforever/p/6511000.html

https://blog.csdn.net/niss/article/details/8764738