iOS设计模式-对象池模式

最新推荐文章于 2022-04-17 16:46:40 发布

agan11423

最新推荐文章于 2022-04-17 16:46:40 发布

阅读量475

点赞数

分类专栏： iOS

本文链接：https://blog.csdn.net/u014275966/article/details/79981008

版权

iOS 专栏收录该内容

73 篇文章 1 订阅

订阅专栏

对象池模式（object pool pattern）是单例的一个变体，可以为组件提供多个完全相同的对象，而非单个对象。当你需要管理一组表示可互相替代的资源对象，切要求同一时间只允许一个组件使用对象时，就可以使用这种模式。

举例说明

图书馆中图书的例子：

可以举例说明图书馆的书的特征，比如说数量是固定的（除非新的采购或者丢失），很多同样的书都不是只有一本，每一本书都可以用来满足不同的读者，而且没一本图书智能被同一个读者借阅。如果所有的图书都借出去了，那么后面的人就拿不到了，只有等到有人归还。

据上我们就可以得出一个结论：图书馆的书可以看成是现实世界中的一组可重用，可相互替代的对象。

对象池模式

对象池模式一般用来管理一组可重用的对象，这些对象的集合被称为对象池。组件可以从对象池中借出对象，用来完成一些任务，用完之后再将它还给对象池。返还的对象姜用于满足调用组件的后续请求，请求可以来自同一个组件，也可以来自另外一个组件。

对象池模式可以用来管理象征显示世界资源的对象，还能通过重复使用对象来满足多个组件的需要。

操作步奏如下：
- 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的时候则会增加计数。

通过上面的这种方法，我们做到了保证借出的对象和返回的对象保持了平衡。

agan11423

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
iOS设计模式-对象池模式

对象池模式（object pool pattern）是单例的一个变体，可以为组件提供多个完全相同的对象，而非单个对象。当你需要管理一组表示可互相替代的资源对象，切要求同一时间只允许一个组件使用对象时，就可以使用这种模式。相关信息1、什么是对象池模式：对象池模式一般用来管理一组可以重用的对象，以供调用组件使用，组件可以从对象中获取对象，用他来完成任务，完成之后将对象还...
复制链接

扫一扫