ObjectPool 对象重用

Posted 2020-11-25 leo_wl

前言

对象池是一种设计模式，一个对象池包含一组已经初始化过且可以使用的对象，而可以在有需求时创建和销毁对象。池的对象可以从池中取得对象，对其进行操作处理，并在不需要时归还给池子而非直接销毁他，他是一种特殊的工厂对象。
若初始化、实例化的代价高，且有需求需要经常实例化，但每次实例化的数量较小的情况下，使用对象池可以过得显著的性能提升。从池子中取得对象的时间是可测的，但新建一个实际所需要的时间是不确定的。

对象池的优势

说到池我们就会联想到很多的概念，如线程池、数据库连接池、内存池等等在多线程设计中可以通过池化机制来进行对象的复用从而提高性能。池的核心优势是 对象复用，这样就免去了对象创建的开销以及回收产生的内容开销，尤其创建对象这是一个很耗时的事情比如IO操作.
拿我们最常见的线程池为例，线程这个对象是可以复用的，程序要执行的任务，这些任务可以交给复用的线程来处理，而线程池创建恰恰又是一个比较耗时的操作，我们通过线程对象的池化技术达到复用线程的目的。

ConcurrentBag实现对象池

池化中需要注意的是多线程中保证线程安全，.NET Framework 4 引入了 System.Collections.Concurrent 命名空间，其中包含多个线程安全且可缩放的集合类。 多个线程可以安全高效地从这些集合添加或删除项，而无需在用户代码中进行其他同步。 编写新代码时，只要将多个线程同时写入到集合时，就使用并发集合类。

ObjectPool

• Get方法用于从对象池获取到可用对象，如果对象不可用则创建对象并返回出来
• Return方法用户将对象返回到对象池

    public class ObjectPool<T>
    {
        private ConcurrentBag<T> _object;
        private Func<T> _objectGenerator;

        public ObjectPool(Func<T> objectGenerator) {
            _object = new ConcurrentBag<T>();
            _objectGenerator = objectGenerator;
        }
        /// <summary>
        ///     取出
        /// </summary>
        /// <returns></returns>
        public T CheckOut() {
            T item;
            if (_object.TryTake(out item)) return item;
            return _objectGenerator();
        }
        /// <summary>
        ///     归还
        /// </summary>
        /// <param name="obj"></param>
        public void CheckIn(T obj) {
            _object.Add(obj);
        }

    }

测试

    class Program
    {
        static void Main(string[] args)
        {
            CancellationTokenSource cts = new CancellationTokenSource();

            // Create an opportunity for the user to cancel.
            Task.Run(() =>
            {
                if (Console.ReadKey().KeyChar == ‘c‘ || Console.ReadKey().KeyChar == ‘C‘)
                    cts.Cancel();
            });

            ObjectPool<MyClass> pool = new ObjectPool<MyClass>(() => new MyClass());

            // Create a high demand for MyClass objects.
            Parallel.For(0, 1000000, (i, loopState) =>
            {
                MyClass mc = pool.CheckOut();
                Console.CursorLeft = 0;
                // This is the bottleneck in our application. All threads in this loop
                // must serialize their access to the static Console class.
                Console.WriteLine("{0:####.####}", mc.GetValue(i));

                pool.CheckIn(mc);
                if (cts.Token.IsCancellationRequested)
                    loopState.Stop();

            });
            Console.WriteLine("Press the Enter key to exit.");
            Console.ReadLine();
            cts.Dispose();
        }

        class MyClass
        {
            public int[] Nums { get; set; }
            public double GetValue(long i)
            {
                return Math.Sqrt(Nums[i]);
            }
            public MyClass()
            {
                Nums = new int[1000000];
                Random rand = new Random();
                for (int i = 0; i < Nums.Length; i++)
                    Nums[i] = rand.Next();
            }
        }


    }

这是一个简单的对象池实现，在实际的场景中还需要考虑最小值，最大值，异常处理等等

总结

在创建资源时会消耗一定的系统资源，尤其在及其复杂的结构中效果相对来说是挺明显的，再加上频繁的创建，实例化消耗的资源是很昂贵的.对象池对这些提成是相当有帮助的.

并非任何情况下都需要使用对象池，在复用生成某种对象的操作成为影响性能因素的时候，才适合采用对象池。如果对象池提成性能提高并不重要的话，还是建议不采用对象池，保持代码简单.

参考

https://zh.m.wikipedia.org/zh-cn/%E5%AF%B9%E8%B1%A1%E6%B1%A0%E6%A8%A1%E5%BC%8F

https://docs.microsoft.com/en-us/dotnet/standard/collections/thread-safe/how-to-create-an-object-pool