对象池模式
基本概念
对象池模式一般用来管理一组可重用对象,以供调用组件使用,它可以为组件提供多个完全相同的对象。组件可以从对象池中获取对象,调用对象后,其他组件在该对象想归还前都无法使用该对象。(Cocoa中 UITableViewCell的重用机制可以通过此模式和工厂模式共同实现)
好处
- 对象构建过程隐藏
- 对象池通过重用机制有效控制对象反复重建造成的消耗。更好的控制内存
实现过程
- 初始化,准备需要的对象集合
- 借出对象,需要对象的组件从池子中借出对象
- 组件使用借到的对象完成任务,对象池保证这个对象在其被归还之前不会再借给其他组件
- 组件返回对象给对象池
注意:
1、在多线程访问中保护对象池数据数组
2、确保每次请求都能获得可用对象
代码示例:
下面代码将模拟一个简单的图书管理过程,包含图书出借和归还等。创建一个macos 命令行项目命名为ObjectPool
- 首先构造 Book类
class Book {
let author:String
let title:String
let stockNumber:Int
var reader:String?
var checkoutCount = 0
init(author:String,title:String,stock:Int) {
self.author = author
self.title = title
self.stockNumber = stock
}
}
- 创建Pool类,这里pool类仅代表对象池。为了方便复用,使用泛型创建。以便可以管理任何类型的对象
//Pool.swift
class Pool<T> {
private var data:[T] = []
init(items:[T]) {
data.reserveCapacity(data.count)
data.append(contentsOf: items)
}
func getFromPool() -> T? {
if data.count > 0 {
return data.remove(at: 0)
}
return nil
}
func returnPool(item:T) {
self.data.append(item)
}
}
修改pool类加入线程保护
class Pool<T> {
private var data:[T] = []
private let dataProtectQueue = DispatchQueue(label: "com.ra.ObjectPool.Pool.DataProtectQueue")
private let semaphore:DispatchSemaphore
init(items:[T]) {
data.reserveCapacity(data.count)
data.append(contentsOf: items)
self.semaphore = DispatchSemaphore(value: items.count)
}
func getFromPool() -> T? {
var result:T?
if semaphore.wait(timeout: DispatchTime.distantFuture) == .success{
dataProtectQueue.sync {
result = self.data.remove(at: 0)
}
}
return result
}
func returnPool(item:T) {
dataProtectQueue.async {
self.data.append(item)
self.semaphore.signal()
}
}
}
- 构造library单例类,用于管理图书
final class Library{
static let shared:Library = Library(stockLevel: 2)
private var books:[Book] = []
private var pool:Pool<Book>
private init(stockLevel:Int){
for count in 1...stockLevel {
let book = Book(author: "xxxx", title: "Design Pattern in Swift", stock: count)
books.append(book)
}
self.pool = Pool(items: books)
}
func checkoutBook(reader:String) -> Book? {
let book = pool.getFromPool()
book?.reader = reader
book?.checkoutCount += 1
return book
}
func returnBook(_ book:Book) {
book.reader = nil
pool.returnPool(item: book)
}
func printReport() {
books.forEach { (book) in
print("....Book#\(book.stockNumber)....")
print("Checked out to \(book.checkoutCount) times ")
if let reader = book.reader{
print("Checked out to \(reader)")
}else{
print("in stock")
}
}
}
}
然后在main.swift中做一个简单调用
let queue = DispatchQueue(label: "work.queue", qos: DispatchQoS.default, attributes: .concurrent)
let group = DispatchGroup()
print("start")
for i in 0..<20{
let workItem = DispatchWorkItem(block: {
if let book = Library.shared.checkoutBook(reader: "reader#\(i)"){
Thread.sleep(forTimeInterval: TimeInterval(arc4random() % 2))
Library.shared.returnBook(book)
}
})
queue.async(group: group, execute: workItem)
}
_ = group.wait(timeout: DispatchTime.distantFuture)
print("all blocks complete")
Library.shared.printReport()
下面是执行结果
Hello, World!
start
all blocks complete
....Book#1....
Checked out to 10 times
in stock
....Book#2....
Checked out to 10 times
in stock
Program ended with exit code: 0
对象池模式的变体
基本概念
更改对象池的运作方式来适应不同的场景
对象池实现设计四种策略:
对象创建策略(对象的创建方式)
积极性策略,即对象在使用前就已经被创建(上面示例代码中pool类的初始化方法属于该类型)
缺点:
- 在需求出现之前就已经花了创建和配置对象所需要的资源
- 创建和配置的对象有可能与需求不相符即对象不可用
惰性策略,即被动型,需要对象的时候才会被创建
代码示例:
在ObjectPool工程中创建BookSeller类。这里的实现方式只是给需求方提供Book的获取方法。其实现不重要
class BookSeller {
class func buyBook(author:String,title:String,stockNumber:Int) -> Book{
return Book(author: author, title: title, stock: stockNumber)
}
}
修改pool类
class Pool<T> {
private var data:[T] = []
private let dataProtectQueue = DispatchQueue(label: "com.ra.ObjectPool.Pool.DataProtectQueue")
private let semaphore:DispatchSemaphore
private var itemCount:Int = 0
private let maxItemCount:Int
private let itemFactory:()->T
init(maxItemCount:Int,factory:@escaping ()->T) {
self.itemFactory = factory
self.maxItemCount = maxItemCount
self.semaphore = DispatchSemaphore(value: maxItemCount)
}
func getFromPool() -> T? {
var result:T?
if semaphore.wait(timeout: DispatchTime.distantFuture) == .success{
dataProtectQueue.sync {
if self.data.count == 0 && self.itemCount < self.maxItemCount{
result = self.itemFactory()
self.itemCount += 1
}else{
result = self.data.removeFirst()
}
}
}
return result
}
func returnPool(item:T) {
dataProtectQueue.async {
self.data.append(item)
self.semaphore.signal()
}
}
func processPoolItems(callBack:(([T]) -> Void)) {
dataProtectQueue.sync {
callBack(self.data)
}
}
}
修改Library类中相关初始化方法
///修改初始化方法
private init(stockLevel:Int){
var stockId = 1
stockId += 1
self.pool = Pool(maxItemCount: stockLevel, factory: { () in
return BookSeller.buyBook(author: "Dickens,Charles", title: "Hard times", stockNumber: stockId)
})
}
///修改打印方法
func printReport() {
pool.processPoolItems { (books) in
books.forEach { (book) in
print("....Book#\(book.stockNumber)....")
print("Checked out to \(book.checkoutCount) times ")
if let reader = book.reader{
print("Checked out to \(reader)")
}else{
print("in stock")
}
}
}
}
对象复用策略
对象池模式的本质决定了它所管理的对象会被重复分配给调用组件,这意味着返还的对象会处于非常正常状态的风险
- 相信策略(默认所有返回对象都是可服用的)
- 不信任策略(对象返回给对象池之前进行检查。不可用就抛弃)
代码修改: 创建PoolItem.Swift文件。并创建协议
protocol PoolItem {
var canReuse:Bool{ get }
}
修改Pool类以及returnToPool方法
class Pool<T> where T:AnyObject {
.....
func returnPool(item:T) {
dataProtectQueue.async {
///对归还对象进行检查
if let pitem = item as? PoolItem {
if pitem.canReuse {
self.data.append(item)
self.semaphore.signal()
}
}
}
}
.....
}
Book类遵守并实现协议
class Book : PoolItem{
let author:String
let title:String
let stockNumber:Int
var reader:String?
var checkoutCount = 0
var canReuse: Bool{
get{
let reusable = checkoutCount < 5
if !reusable {
print("Eject : Book#\(self.stockNumber)")
}
return reusable
}
}
init(author:String,title:String,stock:Int) {
self.author = author
self.title = title
self.stockNumber = stock
}
}
空池策略
对象池中没有对象可满足新的请求时,阻塞请求线程,强制让发起对象请求的线程等待,值到有可用对象后再继续执行
修改main.swift
// 修改为 35次。对象池最多只能返回5个对象。此处修改只为了配合测空池策略
for i in 0..<35{
let workItem = DispatchWorkItem(block: {
if let book = Library.shared.checkoutBook(reader: "reader#\(i)"){
Thread.sleep(forTimeInterval: TimeInterval(arc4random() % 2))
Library.shared.returnBook(book)
}
})
queue.async(group: group, execute: workItem)
}
....
queue.sync {
print("all blocks complete")
Library.shared.printReport()
}
修改pool类
...
func getFromPool(maxWaitSecond:Int = 5) -> T? {
var result:T?
let waitTime = (maxWaitSecond == -1) ? DispatchTime.distantFuture : DispatchTime(uptimeNanoseconds: UInt64(maxWaitSecond*Int(NSEC_PER_SEC)))
if semaphore.wait(timeout: waitTime) == .success{
dataProtectQueue.sync {
if self.data.count == 0 && self.itemCount < self.maxItemCount{
result = self.itemFactory()
self.itemCount += 1
}else{
result = self.data.removeFirst()
}
}
}
return result
}
...
- 弹性对象
此处修改见 demo ObjectPool(弹性对象)
对象分配策略
- 先进先出
- 优先分配使用最少的
等