Creating a threadsafe Array, the easy way?

Question

I've just read a post by Basem Emara about creating a threadsafe array Type in Swift. While I glanced through the code example, I asked myself if there isn't a way to achieve this with quite less code.

Suppose I create this class:

// MARK: Class Declaration
class ThreadsafeArray<Element> {
    // Private Variables
    private var __array: [Element] = []
    private var __arrayQueue: DispatchQueue = DispatchQueue(
        label: "ThreadsafeArray.__concurrentArrayQueue",
        attributes: .concurrent
    )
}


// MARK: Interface
extension ThreadSafeArray {
    // ReadWrite Variables
    var threadsafe: [Element] {
        get {
            return self.__arrayQueue.sync {
                return self.__array
            }
        }
        set(newArray) {
            self.__arrayQueue.async(flags: .barrier) {
                self.__array = newArray
            }
        }
    }
}

If, from now on, I only accessed the actual array through .threadsafe, would this suffice to make the array threadsafe?

Also, could I implement it a struct instead of a class to get the mutating checks as well?

I am aware that the objects inside this array would not be threadsafe themselves through this but this is not the point, so let's assume I only put threadsafe stuff in there.

(Of course, to avoid the calls to .threadsafe, I would make the shiny new class conform to ExpressibleByArrayLiteral, Collection and RangeReplaceableCollection, so I can use it like a normal array.

---

Edit

Meanwhile, I've tried testing it in a playground and have come to believe that it doesn't suffice.

Playground code:

import Foundation
import PlaygroundSupport


PlaygroundPage.current.needsIndefiniteExecution = true

// Testing //
// Thread-unsafe array
func unsafeArray() {
    var array: [Int] = []
    var iterations: Int = 1000
    let start: TimeInterval = Date().timeIntervalSince1970

    DispatchQueue.concurrentPerform(iterations: iterations) { index in
        let last: Int = array.last ?? 0
        array.append(last + 1)

        DispatchQueue.global().sync {
            iterations -= 1

            // Final loop
            guard iterations <= 0 else { return }
            print(String(
                format: "Unsafe loop took %.3f seconds, count: %d.",
                Date().timeIntervalSince1970 - start, array.count
            ))
        }
    }
}

// Thread-safe array
func safeArray() {
    let array: ThreadsafeArray<Int> = ThreadsafeArray<Int>()
    var iterations: Int = 1000
    let start: TimeInterval = Date().timeIntervalSince1970

    DispatchQueue.concurrentPerform(iterations: iterations) { index in
        let last: Int = array.threadsafe.last ?? 0
        array.threadsafe.append(last + 1)

        DispatchQueue.global().sync {
            iterations -= 1

            // Final loop
            guard iterations <= 0 else { return }
            print(String(
                format: "Safe loop took %.3f seconds, count: %d.",
                Date().timeIntervalSince1970 - start, array.threadsafe.count
            ))
        }
    }
}

unsafeArray()
safeArray()

Output:

Most of the time:

experiments(31117,0x7000038d0000) malloc: *** error for object 0x11f663d28: pointer being freed was not allocated

*** set a breakpoint in malloc_error_break to debug

Sometimes:

IndexError: Index out of range

Unfortunately also:

Unsafe loop took 1.916 seconds, count: 994.
Safe loop took 11.258 seconds, count: 515.

Doesn't seem to suffice (also, it's incredibly unperformant).

Answer 1

I suspect this line is your issue:

DispatchQueue.global().sync { ...

If you specify one serial queue you want to use here you should get the result you want.

Something like:

let array = SynchronizedArray<Int>()
var iterations = 1000
let queue = DispatchQueue(label: "queue")

DispatchQueue.concurrentPerform(iterations: 1000) { index in
    array.append(array.last ?? 0)

    queue.sync {
        iterations -= 1

        if iterations == 0 {
            print(array.count)
        }
    }
}

Answer 2

Another method of locking objects is:

func lock(obj: AnyObject, work:() -> ()) {
    objc_sync_enter(obj)
    work()
    objc_sync_exit(obj)
}

Could your class use this to lock its standard array when needed?

Answer 3

I'm surprised the last one is returning any results, but regarding the first two searches, this is quite possible or even expected with Epic. Epic has special logic in the background that evaluates the parameter values you pass in against certain criteria, such as whether the name matches exactly, the name is similar, the birthdate matches exactly, etc. As a result, oftentimes not only exact matches but also similar matches will be returned by the Patient.Search API. The weighting of the criteria is customizable by Epic customer, so some may have stricter logic than others.

I'd recommend always validating the returned result against your input parameters to verify you are working with an exact match.