什么是Swift中等同于Objective-C的"@synchronized"的方法？

为什么要使用锁来增加复杂性和麻烦呢？ 使用 Dispatch Barriers 吧。
Dispatch Barriers 在并发队列中创建了同步点。 在它运行时，即使是并发的且其他核心可用的其他块也不允许运行。 如果这听起来像一个排他（写）锁，那就是它的作用。 非 barrier 块可以被认为是共享（读）锁。 只要所有对资源的访问都通过队列进行，barriers 就提供了非常便宜的同步。

dispatch_barrier_async是更好的方式，而不会阻塞当前线程。

dispatch_barrier_async(accessQueue, { dictionary[object.ID] = object })

基于ɲeuroburɳ，测试一个子类案例

class Foo: NSObject {
    func test() {
        print("1")
        objc_sync_enter(self)
        defer {
            objc_sync_exit(self)
            print("3")
        }

        print("2")
    }
}


class Foo2: Foo {
    override func test() {
        super.test()

        print("11")
        objc_sync_enter(self)
        defer {
            print("33")
            objc_sync_exit(self)
        }

        print("22")
    }
}

let test = Foo2()
test.test()

输出：

1
2
3
11
22
33

另一种方法是创建一个超类，然后继承它。这样你就可以更直接地使用GCD了。

class Lockable {
    let lockableQ:dispatch_queue_t

    init() {
        lockableQ = dispatch_queue_create("com.blah.blah.\(self.dynamicType)", DISPATCH_QUEUE_SERIAL)
    }

    func lock(closure: () -> ()) {
        dispatch_sync(lockableQ, closure)
    }
}


class Foo: Lockable {

    func boo() {
        lock {
            ....... do something
        }
    }