Swift object pool design sample

A generic object pool in Swift

The object pool sample is a creational design sample. The principle concept behind it’s that first you create a set of objects (a pool), then you definitely purchase & launch objects from the pool, as a substitute of continually creating and releasing them. 👍

Why? Efficiency enhancements. For instance the Dispatch framework makes use of an object pool sample to offer pre-created queues for the builders, as a result of making a queue (with an related thread) is an comparatively costly operation.

One other use case of the object pool sample is staff. For instance it’s a must to obtain lots of of photographs from the online, however you’d wish to obtain solely 5 concurrently you are able to do it with a pool of 5 employee objects. Most likely it’s going to be lots cheaper to allocate a small variety of staff (that’ll truly do the obtain process), than create a brand new one for each single picture obtain request. 🖼

What in regards to the downsides of this sample? There are some. For instance when you’ve got staff in your pool, they could include states or delicate person knowledge. It’s a must to be very cautious with them aka. reset the whole lot. Additionally in case you are working in a multi-threaded setting it’s a must to make your pool thread-safe.

Right here is an easy generic thread-safe object pool class:

import Basis

class Pool {

    non-public let lockQueue = DispatchQueue(label: "pool.lock.queue")
    non-public let semaphore: DispatchSemaphore
    non-public var gadgets = [T]()

    init(_ gadgets: [T]) {
        self.semaphore = DispatchSemaphore(worth: gadgets.depend)
        self.gadgets.reserveCapacity(gadgets.depend)
        self.gadgets.append(contentsOf: gadgets)
    }

    func purchase() -> T? {
        if self.semaphore.wait(timeout: .distantFuture) == .success, !self.gadgets.isEmpty {
            return self.lockQueue.sync {
                return self.gadgets.take away(at: 0)
            }
        }
        return nil
    }

    func launch(_ merchandise: T) {
        self.lockQueue.sync {
            self.gadgets.append(merchandise)
            self.semaphore.sign()
        }
    }
}


let pool = Pool(["a", "b", "c"])

let a = pool.purchase()
print("(a ?? "n/a") acquired")
let b = pool.purchase()
print("(b ?? "n/a") acquired")
let c = pool.purchase()
print("(c ?? "n/a") acquired")

DispatchQueue.international(qos: .default).asyncAfter(deadline: .now() + .seconds(2)) {
    if let merchandise = b {
        pool.launch(merchandise)
    }
}

print("No extra useful resource within the pool, blocking thread till...")
let x = pool.purchase()
print("(x ?? "n/a") acquired once more")

As you’ll be able to see the implementation is only a few traces. You will have the thread protected array of the generic pool gadgets, a dispatch semaphore that’ll block if there aren’t any objects out there within the pool, and two strategies in an effort to truly use the thing pool.

Within the pattern you’ll be able to see that if there aren’t any extra objects left within the pool, the present queue might be blocked till a useful resource is being freed & prepared to make use of. So be careful & don’t block the primary thread by chance! 😉