Swiftでのthread-safeなデータ操作

atomic

最近Swiftでもっぱら書くことが多くなり
AtomicReference的なライブラリが欲しく作成してみました。

Lock.swift

class locker {
    private var l = NSRecursiveLock()

    func lock() -> Bool {
        self.l.lock()
        return true
    }

    func unlock() {
        self.l.unlock()
    }

    func safeCall<R>(f: () -> R) -> R {
        var r: R
        self.lock()
        r = f()
        self.unlock()
        return r
    }
}

Atomic.swift

// lockerを継承して、safeCallで安全に値を扱う。
class AtomicValue <T> : locker {
    private var value: T?

    init(v: T?) {
        self.value = v
    }

    func setV(v: T?) {
        self.safeCall(
            {() in
                self.value = v
            }
        )
    }

    func setV(f: (T?) -> T?) {
        self.safeCall(
            {() in
                self.value = f(self.value)
            }
        )
    }

    func getV() -> T? {
        return self.safeCall(
            {() -> T? in
                return self.value
            }
        )
    }

    func getV_and_SetV(v: T?) -> T? {
        return self.safeCall(
            {() -> T? in
                let r = self.value
                self.value = v
                return r
            }
        )
    }
}

使い方

Sample.swift

private var value = AtomicValue <Int> (v: 0)
private var counter: Int {
    get {
        return value.getV()!
    }

    set {
        value.setV(
            {(v: Int?) -> Int? in
                if let vv = v {
                    return vv + 1
                }
                return 0
            }
        )
    }
}

safeCallの中でlockをすると、dead lockになってしまうので
NSRecursiveLockを使っています。

しかし、Swiftは中々慣れない(。。