.NET Core中Object Pool的多种用法详解

前言

复用，是一个重要的话题，也是我们日常开发中经常遇到的，不可避免的问题。

举个最为简单，大家最为熟悉的例子，数据库连接池，就是复用数据库连接。

那么复用的意义在那里呢？

简单来说就是减少不必要的资源损耗。

除了数据库连接，可能在不同的情景或需求下，还会有很多其他对象需要进行复用，这个时候就会有所谓的 object pool(对象池)。

小伙伴们应该也自己实现过类似的功能，或用concurrentbag，或用concurrentqueue，或用其他方案。

这也里分享一个在微软文档中的实现

how to: create an object pool by using a concurrentbag

当然，在.net core中，微软已经帮我们实现了一个简单的object pool。

我们只需要添加microsoft.extensions.objectpool的引用即可使用了。

microsoft.extensions.objectpool

microsoft.extensions.objectpool可以说是.net core的一个基础类库。

它位于aspnet的common项目中，类型其他基础模块都有使用相关的功能，也好比routing项目。

下面就简单看看它的用法。

在开始之前，我们先定义一个可以复用的object

public class demo
{
 public int id { get; set; }
 public string name { get; set; }
 public datetime createtimte { get; set; }
}

用法1

var defalutpolicy = new defaultpooledobjectpolicy<demo>();
//最大可保留对象数量 = environment.processorcount * 2
var defaultpool = new defaultobjectpool<demo>(defalutpolicy);
for (int i = 0; i < poolsize; i++)
{
 item1 = defaultpool.get();
 console.writeline($"#{i+1}-{item1.id}-{item1.name}-{item1.createtimte}");
}

在创建pool之前，我们要先定义一个policy。这里直接用自带的defaultpooledobjectpolicy来构造。

对象池会有一个维护的最大数量，线程数。

通过pool对象的get方法，从对象池中取出一个对象。

上面代码运行结果

#1-0--01/01/0001 00:00:00
#2-0--01/01/0001 00:00:00
#3-0--01/01/0001 00:00:00
#4-0--01/01/0001 00:00:00
#5-0--01/01/0001 00:00:00
#6-0--01/01/0001 00:00:00
#7-0--01/01/0001 00:00:00
#8-0--01/01/0001 00:00:00

这个结果说明，object pool 中的对象都是直接new出来的，并没有对一些属性进行贬值操作，这个时候往往没有太多实际意义。

因为defaultpooledobjectpolicy本来就是直接new了一个对象出来，很多时候，这并不是我们所期望的！

要想符合我们实际的使用，就要自己定义一个policy！

下面来看看用法2

用法2

先定义一个policy，实现 ipooledobjectpolicy 这个接口。t很自然就是我们的demo类了。

public class demopooledobjectpolicy : ipooledobjectpolicy<demo>
{
 public demo create()
 {
  return new demo { id = 1, name = "catcher", createtimte = datetime.now };
 }
 
 public bool return(demo obj)
 {
  return true;
 }
}

这里要实现create和return两个方法。

见名知义，create方法就是用来创建demo对象的，return方法就是将demo对象扔回object pool的(有借有还)。

然后是用demopooledobjectpolicy去替换defaultpooledobjectpolicy。

var demopolicy = new demopooledobjectpolicy();
var defaultpoolwithdemopolicy = new defaultobjectpool<demo>(demopolicy,1);
//借
item1 = defaultpoolwithdemopolicy.get();
//还
defaultpoolwithdemopolicy.return(item1);
//借，但是不还
item2 = defaultpoolwithdemopolicy.get();
console.writeline($"{item1.id}-{item1.name}-{item1.createtimte}");
console.writeline($"{item2.id}-{item2.name}-{item2.createtimte}");
console.writeline(item1 == item2);
//创建一个新的
item3 = defaultpoolwithdemopolicy.get();
console.writeline($"{item3.id}-{item3.name}-{item3.createtimte}");
console.writeline(item3 == item1);

这里定义了对象池只保留一个对象。

由于从object pool中取出来之后，有一步还回去的操作，所以item1和item2应当是同一个对象。

从object pool中拿出了item2之后，它并没有还回去，所以object pool会基于我们定义的policy去创建一个新的对象出来。

下面是用法2的输出结果：

1-catcher-09/17/2018 22:32:38
1-catcher-09/17/2018 22:32:38
true
1-catcher-09/17/2018 22:32:38
false

可以看到item1,item2和item3的各个属性是一样的，并且item1和item2确实是同一个对象。item3和item1并不是同一个。

用法3

除了defaultobjectpool外，还有defaultobjectpoolprovider也可以创建一个object pool。

创建一个object pool，一定是离不开policy的，所以这里还是用了我们自己定义的demopooledobjectpolicy。

var defaultprovider = new defaultobjectpoolprovider();
var policy = new demopooledobjectpolicy();
//default maximumretained is environment.processorcount * 2
objectpool<demo> pool = defaultprovider.create(policy);
item1 = pool.get();
pool.return(item1);
item2 = pool.get();
console.writeline($"{item1.id}-{item1.name}-{item1.createtimte}");
console.writeline($"{item2.id}-{item2.name}-{item2.createtimte}");
console.writeline(item1 == item2);
item3 = pool.get();
console.writeline($"{item3.id}-{item3.name}-{item3.createtimte}");
console.writeline(item3 == item2);

用provider创建object pool时，不能指定保留的最大对象数量，只能用的是默认的environment.processorcount * 2。

后面的使用，和用法2是一样的。

可以看到item1和item2是同一个对象。从object pool中取对象的时候，会取第一个，所以还回去后，再取的话，还是会取到原来的第一个。

item3那里是直接从object pool中取出来的，没有再次创建，因为这里的object pool维护着多个对象，而不是用法2中的只有一个，所以它是直接从pool中拿的。

下面是输出结果

1-catcher-09/17/2018 22:38:34
1-catcher-09/17/2018 22:38:34
true
1-catcher-09/17/2018 22:38:34
false

和用法2，本质是一样的。

用法4

好像上面的用法，都不那么像我们正常使用的。我们还是需要依赖注入的。

那么我们最后就来看看怎么结合依赖注入吧。当然这里的本质还是离不开policy和provider这两个东西。

iservicecollection services = new servicecollection();
services.addsingleton<objectpoolprovider, defaultobjectpoolprovider>();
services.addsingleton(s =>
{
 var provider = s.getrequiredservice<objectpoolprovider>();
 return provider.create(new demopooledobjectpolicy());
});
serviceprovider serviceprovider = services.buildserviceprovider();
var pool = serviceprovider.getservice<objectpool<demo>>();
item1 = pool.get();
pool.return(item1);
item2 = pool.get();
console.writeline($"{item1.id}-{item1.name}-{item1.createtimte}");
console.writeline($"{item2.id}-{item2.name}-{item2.createtimte}");
console.writeline(item1 == item2);
item3 = pool.get();
console.writeline($"{item3.id}-{item3.name}-{item3.createtimte}");
console.writeline(item3 == item2);

我们首先需要完成对provider的注册，然后直接拿它的实例去创建一个object pool即可。

如果想在其他地方用，通过构造函数注入即可。

这里的结果也是和前面一样的，没什么好多说的。

总结

在这几种用法中，我们最常用的应该是用法4。

但是无论那种用法，我们都需要了解，object pool离不开pool，policy和provider这三个家伙。

有了这三个，或许我们就可以为所欲为了。

当然，它还提供了几个特殊的东西，有兴趣的可以去看看。

•leaktrackingobjectpool

•stringbuilderpooledobjectpolicy

最后用一个脑图结束本文。

以上所述是小编给大家介绍的.net core中object pool的多种用法详解，希望对大家有所帮助