Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Creating Thread-Safe Arrays in Swift: http://basememara.com/creating-thread-safe-arrays-in-swift/
import Foundation
import PlaygroundSupport
/// A thread-safe array.
public class SynchronizedArray<Element> {
private let queue = DispatchQueue(label: "io.zamzam.ZamzamKit.SynchronizedArray", attributes: .concurrent)
private var array = [Element]()
public init() { }
public convenience init(_ array: [Element]) {
self.init()
self.array = array
}
}
// MARK: - Properties
public extension SynchronizedArray {
/// The first element of the collection.
var first: Element? {
var result: Element?
queue.sync { result = self.array.first }
return result
}
/// The last element of the collection.
var last: Element? {
var result: Element?
queue.sync { result = self.array.last }
return result
}
/// The number of elements in the array.
var count: Int {
var result = 0
queue.sync { result = self.array.count }
return result
}
/// A Boolean value indicating whether the collection is empty.
var isEmpty: Bool {
var result = false
queue.sync { result = self.array.isEmpty }
return result
}
/// A textual representation of the array and its elements.
var description: String {
var result = ""
queue.sync { result = self.array.description }
return result
}
}
// MARK: - Immutable
public extension SynchronizedArray {
/// Returns the first element of the sequence that satisfies the given predicate.
///
/// - Parameter predicate: A closure that takes an element of the sequence as its argument and returns a Boolean value indicating whether the element is a match.
/// - Returns: The first element of the sequence that satisfies predicate, or nil if there is no element that satisfies predicate.
func first(where predicate: (Element) -> Bool) -> Element? {
var result: Element?
queue.sync { result = self.array.first(where: predicate) }
return result
}
/// Returns the last element of the sequence that satisfies the given predicate.
///
/// - Parameter predicate: A closure that takes an element of the sequence as its argument and returns a Boolean value indicating whether the element is a match.
/// - Returns: The last element of the sequence that satisfies predicate, or nil if there is no element that satisfies predicate.
func last(where predicate: (Element) -> Bool) -> Element? {
var result: Element?
queue.sync { result = self.array.last(where: predicate) }
return result
}
/// Returns an array containing, in order, the elements of the sequence that satisfy the given predicate.
///
/// - Parameter isIncluded: A closure that takes an element of the sequence as its argument and returns a Boolean value indicating whether the element should be included in the returned array.
/// - Returns: An array of the elements that includeElement allowed.
func filter(_ isIncluded: @escaping (Element) -> Bool) -> SynchronizedArray {
var result: SynchronizedArray?
queue.sync { result = SynchronizedArray(self.array.filter(isIncluded)) }
return result!
}
/// Returns the first index in which an element of the collection satisfies the given predicate.
///
/// - Parameter predicate: A closure that takes an element as its argument and returns a Boolean value that indicates whether the passed element represents a match.
/// - Returns: The index of the first element for which predicate returns true. If no elements in the collection satisfy the given predicate, returns nil.
func index(where predicate: (Element) -> Bool) -> Int? {
var result: Int?
queue.sync { result = self.array.index(where: predicate) }
return result
}
/// Returns the elements of the collection, sorted using the given predicate as the comparison between elements.
///
/// - Parameter areInIncreasingOrder: A predicate that returns true if its first argument should be ordered before its second argument; otherwise, false.
/// - Returns: A sorted array of the collection’s elements.
func sorted(by areInIncreasingOrder: (Element, Element) -> Bool) -> SynchronizedArray {
var result: SynchronizedArray?
queue.sync { result = SynchronizedArray(self.array.sorted(by: areInIncreasingOrder)) }
return result!
}
/// Returns an array containing the results of mapping the given closure over the sequence’s elements.
///
/// - Parameter transform: A closure that accepts an element of this sequence as its argument and returns an optional value.
/// - Returns: An array of the non-nil results of calling transform with each element of the sequence.
func map<ElementOfResult>(_ transform: @escaping (Element) -> ElementOfResult) -> [ElementOfResult] {
var result = [ElementOfResult]()
queue.sync { result = self.array.map(transform) }
return result
}
/// Returns an array containing the non-nil results of calling the given transformation with each element of this sequence.
///
/// - Parameter transform: A closure that accepts an element of this sequence as its argument and returns an optional value.
/// - Returns: An array of the non-nil results of calling transform with each element of the sequence.
func compactMap<ElementOfResult>(_ transform: (Element) -> ElementOfResult?) -> [ElementOfResult] {
var result = [ElementOfResult]()
queue.sync { result = self.array.compactMap(transform) }
return result
}
/// Returns the result of combining the elements of the sequence using the given closure.
///
/// - Parameters:
/// - initialResult: The value to use as the initial accumulating value. initialResult is passed to nextPartialResult the first time the closure is executed.
/// - nextPartialResult: A closure that combines an accumulating value and an element of the sequence into a new accumulating value, to be used in the next call of the nextPartialResult closure or returned to the caller.
/// - Returns: The final accumulated value. If the sequence has no elements, the result is initialResult.
func reduce<ElementOfResult>(_ initialResult: ElementOfResult, _ nextPartialResult: @escaping (ElementOfResult, Element) -> ElementOfResult) -> ElementOfResult {
var result: ElementOfResult?
queue.sync { result = self.array.reduce(initialResult, nextPartialResult) }
return result ?? initialResult
}
/// Returns the result of combining the elements of the sequence using the given closure.
///
/// - Parameters:
/// - initialResult: The value to use as the initial accumulating value.
/// - updateAccumulatingResult: A closure that updates the accumulating value with an element of the sequence.
/// - Returns: The final accumulated value. If the sequence has no elements, the result is initialResult.
func reduce<ElementOfResult>(into initialResult: ElementOfResult, _ updateAccumulatingResult: @escaping (inout ElementOfResult, Element) -> ()) -> ElementOfResult {
var result: ElementOfResult?
queue.sync { result = self.array.reduce(into: initialResult, updateAccumulatingResult) }
return result ?? initialResult
}
/// Calls the given closure on each element in the sequence in the same order as a for-in loop.
///
/// - Parameter body: A closure that takes an element of the sequence as a parameter.
func forEach(_ body: (Element) -> Void) {
queue.sync { self.array.forEach(body) }
}
/// Returns a Boolean value indicating whether the sequence contains an element that satisfies the given predicate.
///
/// - Parameter predicate: A closure that takes an element of the sequence as its argument and returns a Boolean value that indicates whether the passed element represents a match.
/// - Returns: true if the sequence contains an element that satisfies predicate; otherwise, false.
func contains(where predicate: (Element) -> Bool) -> Bool {
var result = false
queue.sync { result = self.array.contains(where: predicate) }
return result
}
/// Returns a Boolean value indicating whether every element of a sequence satisfies a given predicate.
///
/// - Parameter predicate: A closure that takes an element of the sequence as its argument and returns a Boolean value that indicates whether the passed element satisfies a condition.
/// - Returns: true if the sequence contains only elements that satisfy predicate; otherwise, false.
func allSatisfy(_ predicate: (Element) -> Bool) -> Bool {
var result = false
queue.sync { result = self.array.allSatisfy(predicate) }
return result
}
}
// MARK: - Mutable
public extension SynchronizedArray {
/// Adds a new element at the end of the array.
///
/// - Parameter element: The element to append to the array.
func append(_ element: Element) {
queue.async(flags: .barrier) {
self.array.append(element)
}
}
/// Adds new elements at the end of the array.
///
/// - Parameter element: The elements to append to the array.
func append(_ elements: [Element]) {
queue.async(flags: .barrier) {
self.array += elements
}
}
/// Inserts a new element at the specified position.
///
/// - Parameters:
/// - element: The new element to insert into the array.
/// - index: The position at which to insert the new element.
func insert(_ element: Element, at index: Int) {
queue.async(flags: .barrier) {
self.array.insert(element, at: index)
}
}
/// Removes and returns the element at the specified position.
///
/// - Parameters:
/// - index: The position of the element to remove.
/// - completion: The handler with the removed element.
func remove(at index: Int, completion: ((Element) -> Void)? = nil) {
queue.async(flags: .barrier) {
let element = self.array.remove(at: index)
DispatchQueue.main.async { completion?(element) }
}
}
/// Removes and returns the elements that meet the criteria.
///
/// - Parameters:
/// - predicate: A closure that takes an element of the sequence as its argument and returns a Boolean value indicating whether the element is a match.
/// - completion: The handler with the removed elements.
func remove(where predicate: @escaping (Element) -> Bool, completion: (([Element]) -> Void)? = nil) {
queue.async(flags: .barrier) {
var elements = [Element]()
while let index = self.array.index(where: predicate) {
elements.append(self.array.remove(at: index))
}
DispatchQueue.main.async { completion?(elements) }
}
}
/// Removes all elements from the array.
///
/// - Parameter completion: The handler with the removed elements.
func removeAll(completion: (([Element]) -> Void)? = nil) {
queue.async(flags: .barrier) {
let elements = self.array
self.array.removeAll()
DispatchQueue.main.async { completion?(elements) }
}
}
}
public extension SynchronizedArray {
/// Accesses the element at the specified position if it exists.
///
/// - Parameter index: The position of the element to access.
/// - Returns: optional element if it exists.
subscript(index: Int) -> Element? {
get {
var result: Element?
queue.sync {
guard self.array.startIndex..<self.array.endIndex ~= index else { return }
result = self.array[index]
}
return result
}
set {
guard let newValue = newValue else { return }
queue.async(flags: .barrier) {
self.array[index] = newValue
}
}
}
}
// MARK: - Equatable
public extension SynchronizedArray where Element: Equatable {
/// Returns a Boolean value indicating whether the sequence contains the given element.
///
/// - Parameter element: The element to find in the sequence.
/// - Returns: true if the element was found in the sequence; otherwise, false.
func contains(_ element: Element) -> Bool {
var result = false
queue.sync { result = self.array.contains(element) }
return result
}
}
// MARK: - Infix operators
public extension SynchronizedArray {
/// Adds a new element at the end of the array.
///
/// - Parameters:
/// - left: The collection to append to.
/// - right: The element to append to the array.
static func +=(left: inout SynchronizedArray, right: Element) {
left.append(right)
}
/// Adds new elements at the end of the array.
///
/// - Parameters:
/// - left: The collection to append to.
/// - right: The elements to append to the array.
static func +=(left: inout SynchronizedArray, right: [Element]) {
left.append(right)
}
}
// Thread-safe array
do {
var array = SynchronizedArray<Int>()
var iterations = 1000
let start = Date().timeIntervalSince1970
DispatchQueue.concurrentPerform(iterations: iterations) { index in
let last = array.last ?? 0
array.append(last + 1)
DispatchQueue.global().sync {
iterations -= 1
// Final loop
guard iterations <= 0 else { return }
let message = String(format: "Safe loop took %.3f seconds, count: %d.",
Date().timeIntervalSince1970 - start,
array.count)
print(message)
}
}
}
PlaygroundPage.current.needsIndefiniteExecution = true
@doctorcolinsmith

This comment has been minimized.

Copy link

doctorcolinsmith commented Dec 14, 2017

This is a really nice bit of code. Any chance of turning this into a framework with a non-viral open source license so I can use it in my app?

Cocoapods support would be a nice bonus ;-)

@karthikAdaptavant

This comment has been minimized.

Copy link

karthikAdaptavant commented Jul 31, 2018

i have tried with Xcode 9.4.1 TSan. Still i am getting race condition
screen shot 2018-07-31 at 2 21 15 pm

@neoneye

This comment has been minimized.

Copy link

neoneye commented Oct 3, 2018

In Xcode10 there is a warning about flatMaphas been renamed to compactMap.

@basememara

This comment has been minimized.

Copy link
Owner Author

basememara commented Dec 5, 2018

I updated to Swift 4.2 and expose some more array functions like reduce and allSatisfy.

From now, this code will be rolled-in and maintained within another library:
https://github.com/ZamzamInc/ZamzamKit/blob/master/Sources/Models/SynchronizedArray.swift

Thanks for all the feedback and comments.

@samishchandra

This comment has been minimized.

Copy link

samishchandra commented Feb 7, 2019

Why [weak self] is not used while submitting tasks to the queue ?

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.
You signed in with another tab or window. Reload to refresh your session. You signed out in another tab or window. Reload to refresh your session.