objc_sync_enter / objc_sync_exit not working with DISPATCH_QUEUE_PRIORITY_LOW

ios, multithreading, swift

Solution

`objc_sync_enter` is an extremely low-level primitive, and isn't intended to be used directly. It's an implementation detail of the old `@synchronized` system in ObjC. Even that is extremely out-dated and should generally be avoided.

Synchronized access in Cocoa is best achieved with GCD queues. For example, this is a common approach that achieves a reader/writer lock (concurrent reading, exclusive writing).

public class UserData {
    private let myPropertyQueue = dispatch_queue_create("com.example.mygreatapp.property", DISPATCH_QUEUE_CONCURRENT)

    private var _myProperty = "" // Backing storage
    public var myProperty: String {
        get {
            var result = ""
            dispatch_sync(myPropertyQueue) {
                result = self._myProperty
            }
            return result
        }

        set {
            dispatch_barrier_async(myPropertyQueue) {
                self._myProperty = newValue
            }
        }
    }
}

All your concurrent properties can share a single queue, or you can give each property its own queue. It depends on how much contention you expect (a writer will lock the entire queue).

The "barrier" in "dispatch_barrier_async" means that it is the only thing allowed to run on the queue at that time, so all previous reads will have completed, and all future reads will be prevented until it completes. This scheme means that you can have as many concurrent readers as you want without starving writers (since writers will always be serviced), and writes are never blocking. On reads are blocking, and only if there is actual contention. In the normal, uncontested case, this is extremely very fast.

Problem

I need a read\write lock for my application. I've read https://en.wikipedia.org/wiki/Readers%E2%80%93writer_lock and wrote my own class, cause there are no read/write lock in swift ``` class ReadWriteLock { var logging = true var b = 0 let r = "vdsbsdbs" // string1 for locking let g = "VSDBVSDBSDBNSDN" // string2 for locking func waitAndStartWriting() { log("wait Writing") objc_sync_enter(g) log("enter writing") } func finishWriting() { objc_sync_exit(g) log("exit writing") } // ждет пока все чтение завершится чтобы начать чтение // и захватить мютекс func waitAndStartReading() { log("wait reading") objc_sync_enter(r) log("enter reading") b++ if b == 1 { objc_sync_enter(g) log("read lock writing") } print("b = \(b)") objc_sync_exit(r) } func finishReading() { objc_sync_enter(r) b-- if b == 0 { objc_sync_exit(g) log("read unlock writing") } print("b = \(b)") objc_sync_exit(r) } private func log(s: String) { if logging { print(s) } } } ``` It works good, until i try to use it from GCD threads. ``` dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0) dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0) ``` When i try to use this class from different async blocks at some moment it allows to write when write is locked here is sample log: ``` wait reading enter reading read lock writing b = 1 wait reading enter reading b = 2 wait reading enter reading b = 3 wait reading enter reading b = 4 wait reading enter reading b = 5 wait reading enter reading b = 6 wait reading enter reading b = 7 wait reading enter reading b = 8 wait reading enter reading b = 9 b = 8 b = 7 b = 6 b = 5 wait Writing enter writing exit writing wait Writing enter writing ``` So, as you can see g was locked, but objc_sync_enter(g) allows to continue. Why could this happen ? BTW i checked how many times ReadWriteLock constructed, and it's 1. Why objc_sync_exit not working and allowing to objc_sync_enter(g) when it's not freed ? PS Readwirtelock defined as ``` class UserData { static let lock = ReadWriteLock() ``` Thanks.

Original source

Related problems