对象池服务可以减少从头创建每个对象的系统开销。在激活对象时，它从池中提取。在停用对象时，它放回池中，等待下一个请求。
我们来看下主线程中，如何与对象池打交道：
static void Main(string[] args)
{
InstancePoolResolver.Register<OrderQueryServiceInterface, OrderQueryService>(); while (true)
{
Thread.Sleep();
Console.Clear(); for (int i = ; i < ;i++ )
{
ThreadPool.QueueUserWorkItem(new WaitCallback(ConsumeObject));
}
}
} private static void ConsumeObject(object state)
{
OrderQueryServiceInterface srv = null;
try
{
using (srv = InstancePoolResolver.Resolve<OrderQueryServiceInterface>()) //从对象池中取得对象，没有可用对象则throw exception
{
Console.WriteLine("Object ID--->" + srv.GetHashCode());
Thread.Sleep(); //故意长时间占用对象
}
}
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<Type, Type> typeMappers = new Dictionary<Type, Type>();
private static Dictionary<Type, int> typeMappersMaxInstanceCount = new Dictionary<Type, int>();
private static Dictionary<Type, List<PoolableObject>> typeInstances = new Dictionary<Type, List<PoolableObject>>(); private static object o4lock = new object();
public static void Register<T, TProvider>()
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<PoolableObject>()); InstanceSettingAttribute setting = GetInstanceSettingAttribute(typeof(TProvider));
typeMappersMaxInstanceCount.Add(t, setting.MaxInstanceGlobal);
}
} public static T Resolve<T>()
where T: PoolableObject
{
Type t = typeof(T);
if (!typeMappers.ContainsKey(t) || !typeInstances.ContainsKey(t))
throw new Exception("Key empty, register please"); lock (o4lock)
{
List<PoolableObject> instances = typeInstances[t];
if (instances == null)
{
instances = new List<PoolableObject>();
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() == )
return new InstanceSettingAttribute() { MaxInstanceGlobal=}; return (InstanceSettingAttribute)attrs[];
}
}
其实很简单，只是多了个获取Attribute的函数