对象池模式(object pool pattern)是单例的一个变体,可以为组件提供多个完全相同的对象,而非单个对象。当你需要管理一组表示可互相替代的资源对象,切要求同一时间只允许一个组件使用对象时,就可以使用这种模式。
相关信息
1、什么是对象池模式:
对象池模式一般用来管理一组可以重用的对象,以供调用组件使用,组件可以从对象中获取对象,用他来完成任务,完成之后将对象还给对象池,以满足组件未来的使用需求,一个对象在被分配给某个调用组件之后,其他组件在它返回对象池之前都是无法使用的。
2、有什么优点
对象池模式将对象的构建过程赢藏起来,使组件无需了解此过程。同时,对象池模式通过重用机制将对象初始化的高昂成本摊销。
3、何时使用此模式
不管是因为需要使用对象时来表示现实世界中的资源,还是因为对象的初始化成本高昂,而需要创建一组完全相同的对象,我们都可以使用对象池模式
4、何时避免使用这种模式
若需要保证任意时刻只存在一个对象,则不应该使用此模式,而应该使用单例模式。如果对存在的对象的数量没有限制的情况下,并允许调用组件自行创建实例,也不应该使用这种模式,使用别的模式。
5、如何确定是否正确使用了这种模式
若能在不创建新实例的情况下给调用组件分配对象,并且相关对象返回到对象池后可以满足组件的后续请求,就说明正确的实现了对象池模式
6、有哪些陷阱
最重要的一个陷阱是并发保护的实施,只有正确的实现了并发保护,才能保证对象的正确分配,确保用于实现此模式的数据结构不会受到损坏
7、有哪些相关的模式
单例模式,管理单个对象。
举例说明
图书馆中图书的例子:
可以举例说明图书馆的书的特征,比如说数量是固定的(除非新的采购或者丢失),很多同样的书都不是只有一本,每一本书都可以用来满足不同的读者,而且没一本图书智能被同一个读者借阅。如果所有的图书都借出去了,那么后面的人就拿不到了,只有等到有人归还。
据上我们就可以得出一个结论:图书馆的书可以看成是现实世界中的一组可重用,可相互替代的对象。
对象池模式
对象池模式一般用来管理一组可重用的对象,这些对象的集合被称为对象池。组件可以从对象池中借出对象,用来完成一些任务,用完之后再将它还给对象池。返还的对象姜用于满足调用组件的后续请求,请求可以来自同一个组件,也可以来自另外一个组件。
对象池模式可以用来管理象征显示世界资源的对象,还能通过重复使用对象来满足多个组件的需要。
操作步奏如下:
- 1、初始化,准备好对象集合
- 2、借出对象
- 3、利用的借出的对象完成一部分任务
- 4、组件将对象返回给对象池
注意问题:
并发的问题,会导致不同的组件借出同一个对象
实现对象池模式
定义一个Pool 类
class Pool<T> {
private var data = [T]();
/// 初始化对象池
///
/// - Parameter items: <#items description#>
init(items:[T]) {
data.reserveCapacity(data.count);
for item in items {
data.append(item);
}
}
/// 从对象池中借出对象
///
/// - Returns: <#return value description#>
func getFromPool() -> T? {
var result:T?;
if data.count > 0 {
result = self.data.remove(at: 0)
}
return result;
}
/// 归还对象给对象池
///
/// - Parameter item: object
func returnToPool(item:T) {
self.data.append(item)
}
}
上面几个方法就完成了对象池的创建和对象的借出归还的操作。
保护数据数组
上面的模式如果发生并发那么应该怎么做呢?我们需要解决:
确保getFromPool和returnToPool不会在两个线程同时被调用
1、利用同步函数来防止并发修改数组:
修改代码如下:
class Pool<T> {
private var data = [T]();
private let arrayQ = DispatchQueue(label: "arrayQ")
/// 初始化对象池
///
/// - Parameter items: <#items description#>
init(items:[T]) {
data.reserveCapacity(data.count);
for item in items {
data.append(item);
}
}
/// 从对象池中借出对象
///
/// - Returns: <#return value description#>
func getFromPool() -> T? {
var result:T?;
if data.count > 0 {
arrayQ.sync {
result = self.data.remove(at: 0)
}
result = self.data.remove(at: 0)
}
return result;
}
/// 归还对象给对象池
///
/// - Parameter item: object
func returnToPool(item:T) {
DispatchQueue.global().async {
self.data.append(item)
}
self.data.append(item)
}
}
不加并发保护也可以实现对象池模式,但是前提是能确保应用永远只有一个线程访问对象池。
使用arrayQ.sync 是为了保证每次只有一个block执行,这样确保了每次只有一个线程能够修改数组,数组中的数据不会受到损坏。
2、确保每次请求都能获得可用的对象
/// 从对象池中借出对象
///
/// - Returns: <#return value description#>
func getFromPool() -> T? {
var result:T?;
if data.count > 0 {
arrayQ.sync {
result = self.data.remove(at: 0)
}
result = self.data.remove(at: 0)
}
return result;
}
上面的代码有个问题就是判断对象的数量是否大于0这里,我们发现一个问题就是当有两个线程同时访问对象时,会造成对象为空的现象。为了解决这个问题我们需要保证除非block百分百可以获得对象,否则就不允许调用getFromPool。
我们使用信号量俩解决这个问题(semaphore)参考信号量
代码参考如下:
class Pool<T> {
private var data = [T]();
private let arrayQ = DispatchQueue(label: "arrayQ")
// 建立信号量
private let semaphore: DispatchSemaphore
/// 初始化对象池
///
/// - Parameter items: <#items description#>
init(items:[T]) {
data.reserveCapacity(data.count);
for item in items {
data.append(item);
}
semaphore = DispatchSemaphore(value: items.count)
}
/// 从对象池中借出对象
///
/// - Returns: <#return value description#>
func getFromPool() -> T? {
var result:T?;
if semaphore.wait(timeout: DispatchTime.distantFuture) == DispatchTimeoutResult.success {
arrayQ.async {
result = self.data.remove(at: 0)
}
}
return result;
}
/// 归还对象给对象池
///
/// - Parameter item: object
func returnToPool(item:T) {
DispatchQueue.global().async {
self.data.append(item)
self.semaphore.signal()
}
self.data.append(item)
}
}
信号量的核心是计数器。当计数器为0的时候,信号量的wait函数会被线程租塞,而调用signal的时候则会增加计数。
通过上面的这种方法,我们做到了保证借出的对象和返回的对象保持了平衡。