通用对象池ObjectPool的一种简易设计和实现方案

最新推荐文章于 2023-05-12 21:04:07 发布
转载 最新推荐文章于 2023-05-12 21:04:07 发布 · 259 阅读 · 1
文章标签：

#c# #数据库 #网络

本文介绍了一个简单的对象池的设计与实现，通过使用线程安全队列ConcurrentQueue实现对象的缓存和复用，旨在减少对象创建和销毁的开销。提供了两种对象分配策略，并附带测试代码。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

对象池，最简单直接的作用当然是通过池来减少创建和销毁对象次数，实现对象的缓存和复用。我们熟知的线程池、数据库连接池、TCP连接池等等都是非常典型的对象池。

一个基本的简易对象池的主要功能实现我认为应该至少包括以下三点：

1、对象的分配、销毁等管理策略

2、线程安全

3、性能

按照主要的常用功能，我们大致可以抽象出以下泛型接口IObjectPool<T>：

IObjectPoolusing System;

/// <summary>
/// Simple ObjectPool Interface
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IObjectPool<T> : IDisposable
{
    #region Properties

    /// <summary>
    /// Minimum enabled object count
    /// </summary>
    int MinObjCount { get; }

    /// <summary>
    /// Maximum enabled object count
    /// </summary>
    int MaxObjCount { get; }

    /// <summary>
    /// Current enabled object count
    /// </summary>
    int CurrentObjCount { get; }

    #endregion

    #region Methods

    /// <summary>
    /// Gets an item from the pool.
    /// </summary>
    /// <returns>The removed or created item.</returns>
    /// <remarks>If the pool is empty, a new item will be created and returned.</remarks>    
    T GetObject();

    /// <summary>
    /// Adds the provided item into the pool.
    /// </summary>
    /// <param name="item">The item to be added.</param>
    void PutObject(T item);

    #endregion

}

 

具体实现这个接口的时候，考虑到线程安全，同时为了降低线程安全控制的种种风险，我们使用framework4.0中提供的线程安全容器，示例代码中选择非常适合这种场景的线程安全队列ConcurrentQueue（时间和空间复杂度都非常合适）：

ObjectPoolusing System;
using System.Collections.Concurrent;

public class ObjectPool<T> : IObjectPool<T> where T : new()
{
    #region 字段

    private readonly IProducerConsumerCollection<T> collection;

    private int _minObjCount = 0;

    private int _maxObjCount = 0;

    #endregion

    #region 构造函数

    public ObjectPool()
        : this(1, 8)
    {
    }

    public ObjectPool(int minObjCount, int maxObjCount)
    {
        if (minObjCount < 1)
        {
            throw new ArgumentException("minObjCount cannot be less than zero");
        }
        if (maxObjCount < 1)
        {
            throw new ArgumentException("maxObjCount cannot be less than zero");
        }
        if (maxObjCount < minObjCount)
        {
            throw new ArgumentException("maxObjCount cannot be less than minObjCount");
        }

        this._minObjCount = minObjCount;
        this._maxObjCount = maxObjCount;
        collection = new ConcurrentQueue<T>();
        var objCount = (minObjCount + maxObjCount) / 2;
        for (int i = 0; i < objCount; i++) //初始化的对象个数取折中方案
        {
            var item = new T();
            collection.TryAdd(item);
        }
    }

    #endregion

    #region 属性

    public int MinObjCount { get { return _minObjCount; } }

    public int MaxObjCount { get { return _maxObjCount; } }

    public int CurrentObjCount
    {
        get
        {
            if (collection != null)
            {
                return collection.Count;
            }
            return 0;
        }
    }

    #endregion

    #region 方法

    public T GetObject()
    {
        T item = default(T);
        var isOK = collection.TryTake(out item);

        //如取出对象为空 此处采用悲观对象分配方案，直接创建一个新对象，保证有对象可用
        if (item == null || isOK == false)
        {
            item = new T();
            this.PutObject(item); //新创建的对象放入容器中
            Console.WriteLine("新创建的对象放入容器中");
        }
        return item;
    }

    public void PutObject(T item)
    {
        if (item == null)
        {
            return;
        }
        collection.TryAdd(item);
        //TryTrimToMax(); //清除大于队列最大可用的项
    }

    public void Dispose()
    {
    }

    #endregion

    #region 辅助方法

    /// <summary>
    /// 清除大于队列最大可用的项
    /// </summary>
    private void TryTrimToMax()
    {
        while (this.collection.Count > this.MaxObjCount)
        {
            var item = default(T);
            this.collection.TryTake(out item);
            Console.WriteLine("清除了大于队列最大可用的项");
        }
    }

    #endregion

}

 

其中，GetObject方法即对象的获取至少有两种策略：

1、悲观对象创建策略
这种策略在获取对象时，“悲观”地认为当对象池中暂无可用对象时，等待是会发生很久时间的，必须保证能够返回一个可用对象，所以不如去掉等待直接创建一个对象返回。虽然并发较高的场景下这有可能造成系统中对象总数暂时超出了最大对象数量限制，但好处是我们可以保证系统有足够的对象可用，不会因为没可用对象或等待创建可用对象而使上层逻辑受阻。
对于对象超过最大对象个数限制的情况，我们完全可以对外再暴露一个接口方法（示例为TryTrimToMax），当系统并发压力减轻时，可调用该方法清理多余的对象。
上面ObjectPool示例代码中我们采取的就是悲观创建对象的方案。

 

2、乐观对象创建策略

这种策略“乐观”地认为，当对象池中暂无可用对象时，所有对象的消费者会在用完对象后及时的返回对象池中。
如果对象池中无可用对象，那么当前请求者可能会选择Sleep或者Wait或WaitOne等方式等待。如果更乐观的话，还可以采用类似lock-free的方式多尝试去获取对象（不完全是CAS的那种lock-free），直到获取对象为止。
这种方式的优点显而易见，它的空间使用率高，不会造成对象超过最大上限。但它的缺点也很明显，在一个高并发的可用对象已经供不应求的环境下，这种策略多数实现都不是wait-free的，没有获取到对象的请求调用只能排队等待，这就极大地降低了系统吞吐量，原来的对象池是为了提高性能的，现在则成了系统性能瓶颈的重要原因。

上述示例代码中，泛型参数T有where限制，可通过Func委托间接去掉这个限制，当然构造函数会略微变得复杂：

ObjectPoolusing System;
using System.Collections.Concurrent;

public class ObjectPool<T> : IObjectPool<T>
{
    #region 字段

    private readonly IProducerConsumerCollection<T> collection;

    private readonly Func<T> _generator;

    private int _minObjCount = 0;

    private int _maxObjCount = 0;

    #endregion

    #region 构造函数

    public ObjectPool(Func<T> generator)
        : this(generator, 1, 8)
    {
    }

    public ObjectPool(Func<T> generator, int minObjCount, int maxObjCount)
    {
        if (generator == null)
        {
            throw new ArgumentNullException("generator cannot be null");
        }
        if (minObjCount < 1)
        {
            throw new ArgumentException("minObjCount cannot be less than zero");
        }
        if (maxObjCount < 1)
        {
            throw new ArgumentException("maxObjCount cannot be less than zero");
        }
        if (maxObjCount < minObjCount)
        {
            throw new ArgumentException("maxObjCount cannot be less than minObjCount");
        }
        this._generator = generator;
        this._minObjCount = minObjCount;
        this._maxObjCount = maxObjCount;
        collection = new ConcurrentQueue<T>();
        var objCount = (minObjCount + maxObjCount) / 2;
        for (int i = 0; i < objCount; i++) //初始化的对象个数取折中方案
        {
            var item = _generator();
            collection.TryAdd(item);
        }
    }

    #endregion

    #region 属性

    public int MinObjCount { get { return _minObjCount; } }

    public int MaxObjCount { get { return _maxObjCount; } }

    public int CurrentObjCount
    {
        get
        {
            if (collection != null)
            {
                return collection.Count;
            }
            return 0;
        }
    }

    #endregion

    #region 方法

    public T GetObject()
    {
        T item = default(T);
        var isOK = collection.TryTake(out item);

        //如取出对象为空 此处采用悲观对象分配方案，直接创建一个新对象，保证有对象可用
        if (item == null || isOK == false)
        {
            item = _generator();
            this.PutObject(item); //新创建的对象放入容器中
            Console.WriteLine("新创建的对象放入容器中");
        }
        return item;
    }

    public void PutObject(T item)
    {
        if (item == null)
        {
            return;
        }
        collection.TryAdd(item);
        //TryTrimToMax(); //清除大于队列最大可用的项
    }

    public void Dispose()
    {
    }

    #endregion

    #region 辅助方法

    /// <summary>
    /// 清除大于队列最大可用的项
    /// </summary>
    private void TryTrimToMax()
    {
        while (this.collection.Count > this.MaxObjCount)
        {
            var item = default(T);
            this.collection.TryTake(out item);
            Console.WriteLine("清除了大于队列最大可用的项");
        }
    }

    #endregion

}

 

可通过下列代码进行测试验证：

ObjectPoolTestusing System;
using System.Threading;
using System.Threading.Tasks;

class UserService
{
    public void CheckUser(int i)
    {
        //Console.WriteLine("check user:{0}", i);
        Thread.Sleep(1);
    }
}

public class Program
{
    static void Main(string[] args)
    {
        TestObjectPool();

        for (int a = 0; a < 10; a++)
        {
            Console.WriteLine("测试：{0}", a + 1);
            TestObjectPool();
        }

        Console.Read();
    }

    static void TestObjectPool()
    {
        var recordCount = 10000;
        using (var pool = new ObjectPool<UserService>(() => { return new UserService(); }, 1, 16))
        //using (var pool = new ObjectPool<UserService>(() => { return new UserService(); }, 1, 128))
        {
            Console.WriteLine("Init:current obj count:{0}", pool.CurrentObjCount);
            Parallel.For(0, recordCount, i =>
            {
                var service = pool.GetObject();
                service.CheckUser(i);
                Thread.Sleep(2);
                pool.PutObject(service);
            });

            Console.WriteLine("current obj count:{0}", pool.CurrentObjCount);
            Console.WriteLine("min obj count:{0}", pool.MinObjCount);
            Console.WriteLine("max obj count:{0}", pool.MaxObjCount);
            Console.WriteLine("====================");
        }
    }
}

 

本文的对象池实现较为简洁，只有基本的存取功能，其他功能如对象的销毁等可以继续扩展。还要感慨下幸好有了线程安全容器，果然可以成倍地提高生产效率，而且代码更加简洁优雅。

 

参考：

http://blogs.msdn.com/b/pfxteam/archive/2010/04/13/9990427.aspx

http://code.msdn.microsoft.com/parextsamples

【Unity小技巧】Unity探究自制对象池和官方内置对象池（ObjectPool）的使用
向宇
08-18 3529
什么是对象池？ 对象池的作用？ 我们该如何使用对象池？
【Unity】传统对象池构造和Unity官方对象池ObjectPool使用
simplenthpower的博客
03-11 1718
目标：在画面中生成大量Cube。
Unity3D GameObject对象通用的对象池，可以管理任意多个GameObject对象，支持延迟释放
12-03
Unity3D GameObject对象通用的对象池。 可以管理任意多个GameObject对象。 支持延迟释放。 可以设置缓存对象的最大数量。 设置对象ID，通过ID快速查找对象。 也可以通过派生接口，自动释放。
一个通用并发对象池的实现
spidercoco的专栏
02-28 1765
英文原文链接 本文最早发表于deepinmind 这篇文章里我们主要讨论下如何在Java里实现一个对象池。最近几年，Java虚拟机的性能在各方面都得到了极大的提升，因此对大多数对象而言，已经没有必要通过对象池来提高性能了。根本的原因是，创建一个新的对象的开销已经不像过去那样昂贵了。 然而，还是有些对象，它们的创建开销是非常大的。比如线程，数据库连接等这些非轻量级的对象，创建这些对
Unity编程标准导引-3.4 Unity中的对象池
weixin_30655219的博客
02-20 248
本文为博主原创文章，欢迎转载。请保留博主链接http://blog.csdn.net/andrewfan Unity编程标准导引-3.4 Unity中的对象池 　　本节通过一个简单的射击子弹的示例来介绍Transform的用法。子弹射击本身很容易制作，只要制作一个子弹Prefab，再做一个发生器，使用发生器按频率产生子弹，即克隆子弹Prefab，然后为每个子弹写上运动逻辑就可以了。这本该是...
Unity 通用对象池
m0_66744030的博客
05-12 281
再使用PoolManger类来实现对象池的使用，列如我想实现子弹预制体，和敌人预制体，可以扩展更多，如特效预制体，敌人子弹预制体，使用方法在Hierarchy面板生成个空对象，挂载PoolManager脚本。后面只用控制子弹禁用和开启，节约性能；学习b站up主阿严Gaming。生成pool类方便实例化物体。使用方法，如子弹发射。
通用对象池GenericObjectPool
程序员的博客
10-14 5940
GenericObjectPool 是Apache Commons Pool提供的对象池，使用的时候需要调用 borrowObject 获取一个对象，使用完以后需要调用 returnObject 归还对象，或者调用 invalidateObject 将这个对象标记为不可再用。 GenericObjectPool创建时，可以用有参构造函数进行初始化，通过GenericObjectPoolConfig 和PooledObjectFactory来进行参数的初始化和对象工厂类的引入。 PooledObje...
Unity 对象池插件 Easy ObjectPool 2.0
02-23
Unity 轻量高效对象池插件 // // 摘要: // 首次加载是否完成 public static bool firstPreloadFinish { get; } // // 摘要: // 获取实例 public static EasyObjectPool GetInstance(); // // 摘要: //...
ObjectPool:Android 对象池
06-04
对象池模式是一种软件创建设计模式，它使用一组随时可用的初始化对象——一个“池”——而不是按需分配和销毁它们。 池的客户端将从池中请求一个对象并对返回的对象执行操作。 当客户端完成后，它将对象返回到池中...
多线程：从对象池（objectpool）谈同步(syncronization)——一个调试的问题
02-21
还记得JeffryRichter在《Appiled.NETFrameworkProgramming》里的那个利用对象复苏设计的那个对象池吗？且请容许我把代码在这里再贴一遍： 1using System; 2 3using System.Collections; 4 5 
万能对象池【C#实现】
07-22
万能对象池【C#实现】
C#自定义对象池
02-24
C# 实现自定义对象池，在数据库操作的时候，频繁的创建、关闭连接，消耗许多资源。自定义一个对象池，在对象池中始终保留几个可用连接，不用每次都重新创建。 初始版本，目前还不知道性能咋样。
【Unity】通用对象池
萧然
10-28 353
最近做一款音乐游戏，需要显示较多的音符，需频繁回收利用GameObject，简易的对象池满足不了需求，以前写过几个对象池， 使用起来有比较有局限性，不是很方便，就考虑写一个通用的对象池，可以适用于各种项目类型，而且调用要简便。参考了一些资料，并利用This添加了静态方法，方便调用，就此有了万能对象池~（大佬们看见不要打我 ···） 使用前只需要创建一个池，加载对象到场景时调用创建方法，销毁时调...
通用并发对象池
最佳 Java 编程
05-11 235
在本文中，我们将介绍如何在Java中创建对象池。 近年来，JVM的性能成倍增加，大多数类型的对象几乎都变得多余，从而提高了对象池的性能。 从本质上讲，对象的创建不再像以前那样昂贵。 但是，有些对象在创建时肯定会付出高昂的代价。 诸如线程，数据库连接对象等对象不是轻量级对象，并且创建起来会稍微贵一些。 在任何应用程序中，我们都需要使用上述多种对象。 因此，如果有一种非常容易的方法可以轻松创建...
Objectpool (对象池) 带实例
QWBin的博客
09-19 2355
之前发了缓存池的用法，那么索性把对象池也写一个把。 首先是Unity布置： 代码直接给“Main Camera” 预制体添加刚体：也就是要发射的子弹。 Poolable代码： public class Poolable : MonoBehaviour {     public string key;     public bool isPooled; } POOL代码： ...
C# LIFOPool 对象池
Rocky的专栏
06-05 168
C# LIFOPool 对象池 代码 public class LIFOPool<T> : IPool<T>, IFreeness where T : class { #region NestedTypes internal struct LIFOEntry { ...
用C#建立通用对象池
FindingMySelf的专栏
12-09 1192
用C#建立通用对象池[1] 　　在系统设计中，经常会使用“池”的概念。比如数据库连接池，socket连接池，线程池，组件队列。“池”可以节省对象重复创建和初始化所耗费的时间，可以简化对象获取和使用的过程。对于那些被系统频繁请求和使用的对象，如果使用这种机制，可以使系统性能得到很大提高。特别象数据库连接这种对象，客户端与数据库服务器端建立连接时，是比较慢的，如果每次进行数据库操作，都要先进行数据
用C＃建立通用对象池[1]
在路上
03-14 4096
 在系统设计中，经常会使用“池”的概念。比如数据库连接池，socket连接池，线程池，组件队列。“池”可以节省对象重复创建和初始化所耗费的时间，可以简化对象获取和使用的过程。对于那些被系统频繁请求和使用的对象，如果使用这种机制，可以使系统性能得到很大提高。特别象数据库连接这种对象，客户端与数据库服务器端建立连接时，是比较慢的，如果每次进行数据库操作，都要先进行数据库连接，系统效率将非常低下。
C# ThreadContextPool 对象池
Rocky的专栏
06-05 151
C# ThreadContextPool 对象池 public class ThreadContextPool<T> where T : class { #region NestedType private struct Entry { public int Thre...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值