**Approach — brief**Use a bounded pool (fixed max size) backed by a thread-safe lock-free queue where possible. Use DispatchSemaphore to bound concurrent buffers and a concurrent DispatchQueue with barrier writes to minimize contention. Use weak references in cache and allow OS to reclaim via autoreleasepool by storing buffers as plain Data (value type) or Boxed weak references only for class-backed buffers.swift
import Foundation
final class DataBuffer {
var data: Data
init(capacity: Int) { data = Data(count: capacity) }
func reset() { data.removeAll(keepingCapacity: true) }
}
final class BufferPool {
private let maxSize: Int
private var stack: [DataBuffer] = []
private let queue = DispatchQueue(label: "buffer.pool.queue", attributes: .concurrent)
private let semaphore: DispatchSemaphore
init(maxSize: Int = 16, bufferCapacity: Int = 4096) {
self.maxSize = maxSize
self.semaphore = DispatchSemaphore(value: maxSize)
// prefill lazily to avoid holding memory until needed
}
func acquire(bufferCapacity: Int = 4096) -> DataBuffer {
// Wait but allow caller to proceed only when a slot is available
semaphore.wait()
var buf: DataBuffer?
queue.sync {
buf = stack.popLast()
}
if let b = buf { b.reset(); return b }
return DataBuffer(capacity: bufferCapacity)
}
func release(_ buffer: DataBuffer) {
buffer.reset()
// try to store; if pool is full, drop buffer so it can be deallocated
queue.async(flags: .barrier) {
if self.stack.count < self.maxSize {
self.stack.append(buffer)
} else {
// drop buffer — allow deinit / ARC to free memory
}
self.semaphore.signal()
}
}
}
