C# 对象池的实现(能限制最大实例数量，类似于WCF的MaxInstanceCount功能)-白红宇

C# 对象池的实现(能限制最大实例数量，类似于WCF的MaxInstanceCount功能)

阅读量：737 次

发布时间：2019-03-22

本文共 3079 字，大约阅读时间需要 10 分钟。

对象池服务可以减少从头创建每个对象的系统开销。在激活对象时，它从池中提取。在停用对象时，它放回池中，等待下一个请求。

我们来看下主线程中，如何与对象池打交道：

static void Main(string[] args)        {            InstancePoolResolver.Register
    
     ();            while (true)            {                Thread.Sleep(2000);                Console.Clear();                for (int i = 0; i < 20;i++ )                {                    ThreadPool.QueueUserWorkItem(new WaitCallback(ConsumeObject));                }            }        }        private static void ConsumeObject(object state)        {            OrderQueryServiceInterface srv = null;            try            {                using (srv = InstancePoolResolver.Resolve
     
      ())  //从对象池中取得对象，没有可用对象则throw exception                {                    Console.WriteLine("Object ID--->" + srv.GetHashCode());                    Thread.Sleep(1000);  //故意长时间占用对象                }            }            catch (Exception ex)            {                Console.WriteLine(ex.Message);            }            finally            {                if (srv != null)                    srv.Dispose();            }        }

运行效果：

最多只有2个instance，那在哪里设置这个数量呢？请看

是通过Attribute打tag上去的

下面来看看最核心的InstancePoolResolver类

public sealed class InstancePoolResolver    {        private static Dictionary
    
      typeMappers = new Dictionary
     
      ();        private static Dictionary
      
        typeMappersMaxInstanceCount = new Dictionary
       
        ();        private static Dictionary
        
         > typeInstances = new Dictionary
         
          >(); private static object o4lock = new object(); public static void Register
          
           () where TProvider : class, new() { if (typeMappers.ContainsKey(typeof(T))) throw new Exception("Key existed"); lock (o4lock) { Type t = typeof(T); typeMappers.Add(t, typeof(TProvider)); typeInstances.Add(t, new List
           
            ()); InstanceSettingAttribute setting = GetInstanceSettingAttribute(typeof(TProvider)); typeMappersMaxInstanceCount.Add(t, setting.MaxInstanceGlobal); } } public static T Resolve
            
             () where T: PoolableObject { Type t = typeof(T); if (!typeMappers.ContainsKey(t) || !typeInstances.ContainsKey(t)) throw new Exception("Key empty, register please"); lock (o4lock) { List
             
               instances = typeInstances[t]; if (instances == null) { instances = new List
              
               (); typeInstances[t] = instances; } foreach (PoolableObject o in instances)//是否已经存在已有闲置对象 { if (o.IsInPool) { o.IsInPool = false; return (T)o; } } if (instances.Count < typeMappersMaxInstanceCount[t])//new新对象到对象池中 { Type type = typeMappers[t]; PoolableObject obj = (PoolableObject)Activator.CreateInstance(type); instances.Add(obj); obj.IsInPool = false; return (T)obj; } } throw new Exception("Object Pool fulled!"); //没有多余的资源 } private static InstanceSettingAttribute GetInstanceSettingAttribute(Type type) { object[] attrs = type.GetCustomAttributes(typeof(InstanceSettingAttribute), false); if (attrs == null || attrs.Count() == 0) return new InstanceSettingAttribute() { MaxInstanceGlobal=10}; return (InstanceSettingAttribute)attrs[0]; } }