Automatic Atomic Unique ID for Hashable Protocol

Question

I was playing around with a Singleton to generate unique ID's to conform to Hashable. Then I realised it wasn't really thread safe. So I switched to OSAtomicIncrement32 because it does not use a closure, so it can be as simple as this:

class HashID {

    static let sharedID = HashID()

    private var storedGlobalID : Int32 = 0
    var newID : Int {
        get {
            return Int(OSAtomicIncrement32(&storedGlobalID))
        }
    }

    private init() {}
}

Then I wanted to try a HashID for each Type. So I use _stdlib_getDemangledTypeName reflecting to feed a Dictionary. But then again it wasn't thread safe. Different threads can now manipulate the Dictionary at the same time.

class HashID {

    static let sharedID = HashTypeID()

    func idForType(type: Any.Type) -> Int {

        let typeName = _stdlib_getDemangledTypeName(type)

        guard let currentID = storedGlobalIDForType[typeName] else {

            let currentID : Int32 = 0
            storedGlobalIDForType[typeName] = currentID
            return Int(currentID)

        }

        let newID = atomicIncrement(currentID)
        storedGlobalIDForType[typeName] = newID
        return Int(newID)

    }

    private var storedGlobalIDForType : [String:Int32] = [String:Int32]()

    private func atomicIncrement(var value: Int32) -> Int32 {
        return OSAtomicIncrement32(&value)
    }

    private init() {}

}

I can obviously use GCD, but that means using closures and then I can't use a simple function with a return value. Using a completionHandler is just less "clean" and it also makes it more complicated to set this in the init of a class / struct.

This means default ID's and this would make them unhashable until the ID is fetched, or I would have to have an init with a completionHandler of it's own. -> forgot how dispatch_sync works.

As I said, I was just playing around with this code. The first function is perfectly fine. The second however also gives a count of all instances of a type that were created. Which is not the most useful thing ever...

Is there some way I am forgetting to make the access to the Dictionary thread safe?

---

Updated Code:

credits to Martin R and Nikolai Ruhe

class HashTypeID {
    // shared instance
    static let sharedID = HashTypeID()

    // dict for each type
    private var storedGlobalIDForType : [String:Int] = [String:Int]()

    // serial queue
    private let _serialQueue = dispatch_queue_create("HashQueue", DISPATCH_QUEUE_SERIAL)


    func idForType(type: Any.Type) -> Int {

        var id : Int = 0

        // make it thread safe
        dispatch_sync(_serialQueue) {

            let typeName = String(reflecting: type)

            // check if there is already an ID
            guard let currentID = self.storedGlobalIDForType[typeName] else {

                // if there isn't an ID, store one
                let currentID : Int = 0
                self.storedGlobalIDForType[typeName] = currentID
                id = Int(currentID)

                return
            }

            // if there is an ID, increment
            id = currentID
            id++

            // store the incremented ID
            self.storedGlobalIDForType[typeName] = id
        }

        return id
    }

    private init() {}

}

Answer 1

Is there some way I am forgetting to make the access to the Dictionary thread safe?

Many. Using dispatch_sync on a serial queue is a good and simple way to go:

class HashID {

    static func idForType(type: Any.Type) -> Int {

        let typeName = _stdlib_getDemangledTypeName(type)
        var id : Int = 0

        dispatch_sync(queue) {

            if let currentID = storedGlobalIDForType[typeName] {
                id = currentID + 1
                storedGlobalIDForType[typeName] = id
            } else {
                storedGlobalIDForType[typeName] = 0
            }
        }

        return id
    }

    private static var queue = dispatch_queue_create("my.queue", DISPATCH_QUEUE_SERIAL)
    private static var storedGlobalIDForType : [String : Int] = [:]
}

Using a read write lock could have advantages in your case.