有什么方法可以像 C# 一样在 Swift 中锁定对象

Question

我有以下代码：

func foo() {
    var sum = 0
    var pendingElements = 10

    for i in 0 ..< 10 {
        proccessElementAsync(i) { value in
            sum += value
            pendingElements--

            if pendingElements == 0 {
                println(sum)
            }
        }
    }
}

在这种情况下，函数proccessElementAsync，顾名思义，异步处理其输入参数，并在完成时调用其相应的完成处理程序。

这种方法的不便之处在于，由于变量 pendingElements 是通过多个线程访问的，那么语句 if pendingElements == 0 可能永远不会具有值 true。

在 C# 中，我们可以执行以下操作：

Object lockObject = new Object();
...

lock (lockObject) {
    pendingElements--;

    if (pendingElements == 0) {
        Console.WriteLine(sum);
    }
}

这确保了这个变量只能同时被一个线程访问。有什么方法可以在 Swift 中获得相同的行为？

Answer 1

没有本机锁定工具，但有类似这个 SO 问题中解释的解决方法：

What is the Swift equivalent to Objective-C's "@synchronized"?

使用其中一个答案，您可以创建一个函数：

    func synchronize(lockObj: AnyObject!, closure: ()->()){
        objc_sync_enter(lockObj)
        closure()
        objc_sync_exit(lockObj)
    }

然后：

     func foo() {
        var sum = 0
        var pendingElements = 10

        for i in 0 ..< 10 {
            processElementAsync(i) { value in

                synchronize(pendingElements) {
                    sum += value
                    pendingElements--

                    if pendingElements == 0 {
                        println(sum)
                    }
                }

            }
        }
    }

Answer 2

希望这会对你有所帮助。

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

var pendingElements = 10

func foo() {
    var sum = 0
    var pendingElements = 10

    for i in 0 ..< 10 {
        proccessElementAsync(i) { value in

            lock(pendingElements) {
                sum += value
                pendingElements--

                if pendingElements == 0 {
                    println(sum)
                }
            }

        }
    }
}