什么是 Swift 等价于 Objective-C 的“@synchronized”？

Question

我搜索了 Swift 书籍，但找不到 @synchronized 的 Swift 版本。如何在 Swift 中进行互斥？

Answer 1

怎么样

final class SpinLock {
    private let lock = NSRecursiveLock()

    func sync<T>(action: () -> T) -> T {
        lock.lock()
        defer { lock.unlock() }
        return action()
    }
}

Answer 2

试试：NSRecursiveLock

同一个线程可以多次获取的锁 导致死锁。

let lock = NSRecursiveLock()

func f() {
    lock.lock()
    //Your Code
    lock.unlock()
}

func f2() {
    lock.lock()
    defer {
        lock.unlock()
    }
    //Your Code
}

Objective-C 同步功能支持递归和 可重入代码。一个线程可以在一个线程中多次使用一个信号量 递归方式；其他线程被阻止使用它，直到 线程释放所有用它获得的锁；也就是说，每 @synchronized() 块正常退出或通过异常退出。 Source

Answer 3

详情

Xcode 8.3.1、Swift 3.1

任务

从不同线程读取写入值（异步）。

代码

class AsyncObject<T>:CustomStringConvertible {
    private var _value: T
    public private(set) var dispatchQueueName: String
   
    let dispatchQueue: DispatchQueue
    
    init (value: T, dispatchQueueName: String) {
        _value = value
        self.dispatchQueueName = dispatchQueueName
        dispatchQueue = DispatchQueue(label: dispatchQueueName)
    }
    
    func setValue(with closure: @escaping (_ currentValue: T)->(T) ) {
        dispatchQueue.sync { [weak self] in
            if let _self = self {
                _self._value = closure(_self._value)
            }
        }
    }
    
    func getValue(with closure: @escaping (_ currentValue: T)->() ) {
        dispatchQueue.sync { [weak self] in
            if let _self = self {
                closure(_self._value)
            }
        }
    }
    
    
    var value: T {
        get {
            return dispatchQueue.sync { _value }
        }
        
        set (newValue) {
            dispatchQueue.sync { _value = newValue }
        }
    }

    var description: String {
        return "\(_value)"
    }
}

用法

print("Single read/write action")
// Use it when when you need to make single action
let obj = AsyncObject<Int>(value: 0, dispatchQueueName: "Dispatch0")
obj.value = 100
let x = obj.value
print(x)

print("Write action in block")
// Use it when when you need to make many action
obj.setValue{ (current) -> (Int) in
    let newValue = current*2
    print("previous: \(current), new: \(newValue)")
    return newValue
}

完整样本

扩展调度组

extension DispatchGroup {
    
    class func loop(repeatNumber: Int, action: @escaping (_ index: Int)->(), completion: @escaping ()->()) {
        let group = DispatchGroup()
        for index in 0...repeatNumber {
            group.enter()
            DispatchQueue.global(qos: .utility).async {
                action(index)
                group.leave()
            }
        }
        
        group.notify(queue: DispatchQueue.global(qos: .userInitiated)) {
            completion()
        }
    }
}

类视图控制器

import UIKit

class ViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()

        //sample1()
        sample2()
    }
    
    func sample1() {
        print("=================================================\nsample with variable")
        
        let obj = AsyncObject<Int>(value: 0, dispatchQueueName: "Dispatch1")
        
        DispatchGroup.loop(repeatNumber: 5, action: { index in
            obj.value = index
        }) {
            print("\(obj.value)")
        }
    }
    
    func sample2() {
        print("\n=================================================\nsample with array")
        let arr = AsyncObject<[Int]>(value: [], dispatchQueueName: "Dispatch2")
        DispatchGroup.loop(repeatNumber: 15, action: { index in
            arr.setValue{ (current) -> ([Int]) in
                var array = current
                array.append(index*index)
                print("index: \(index), value \(array[array.count-1])")
                return array
            }
        }) {
            print("\(arr.value)")
        }
    }
}

Answer 4

综上，这里给出更常见的方式，包括返回值或void，以及抛出

import Foundation

extension NSObject {


    func synchronized<T>(lockObj: AnyObject!, closure: () throws -> T) rethrows ->  T
    {
        objc_sync_enter(lockObj)
        defer {
            objc_sync_exit(lockObj)
        }

        return try closure()
    }


}

Answer 5

使用 Swift 的属性包装器，这就是我现在使用的：

@propertyWrapper public struct NCCSerialized<Wrapped> {
    private let queue = DispatchQueue(label: "com.nuclearcyborg.NCCSerialized_\(UUID().uuidString)")

    private var _wrappedValue: Wrapped
    public var wrappedValue: Wrapped {
        get { queue.sync { _wrappedValue } }
        set { queue.sync { _wrappedValue = newValue } }
    }

    public init(wrappedValue: Wrapped) {
        self._wrappedValue = wrappedValue
    }
}

那么你可以这样做：

@NCCSerialized var foo: Int = 10

或

@NCCSerialized var myData: [SomeStruct] = []

然后像往常一样访问变量。

Answer 6

在现代 Swift 5 中，具有返回功能：

/**
Makes sure no other thread reenters the closure before the one running has not returned
*/
@discardableResult
public func synchronized<T>(_ lock: AnyObject, closure:() -> T) -> T {
    objc_sync_enter(lock)
    defer { objc_sync_exit(lock) }

    return closure()
}

像这样使用它，以利用返回值功能：

let returnedValue = synchronized(self) { 
     // Your code here
     return yourCode()
}

或者这样：

synchronized(self) { 
     // Your code here
    yourCode()
}

Answer 7

在 2018 年 WWDC 的“了解崩溃和崩溃日志”session 414 中，他们展示了以下使用带同步的 DispatchQueues 的方式。

在 swift 4 中应该是这样的：

class ImageCache {
    private let queue = DispatchQueue(label: "sync queue")
    private var storage: [String: UIImage] = [:]
    public subscript(key: String) -> UIImage? {
        get {
          return queue.sync {
            return storage[key]
          }
        }
        set {
          queue.sync {
            storage[key] = newValue
          }
        }
    }
}

无论如何，您也可以使用带屏障的并发队列来加快读取速度。同步和异步读取是同时执行的，写入新值会等待先前的操作完成。

class ImageCache {
    private let queue = DispatchQueue(label: "with barriers", attributes: .concurrent)
    private var storage: [String: UIImage] = [:]

    func get(_ key: String) -> UIImage? {
        return queue.sync { [weak self] in
            guard let self = self else { return nil }
            return self.storage[key]
        }
    }

    func set(_ image: UIImage, for key: String) {
        queue.async(flags: .barrier) { [weak self] in
            guard let self = self else { return }
            self.storage[key] = image
        }
    }
}

Answer 8

图我将发布基于先前答案的 Swift 5 实现。多谢你们！我发现有一个返回值也很有帮助，所以我有两种方法。

这是一个简单的类：

import Foundation
class Sync {
public class func synced(_ lock: Any, closure: () -> ()) {
        objc_sync_enter(lock)
        defer { objc_sync_exit(lock) }
        closure()
    }
    public class func syncedReturn(_ lock: Any, closure: () -> (Any?)) -> Any? {
        objc_sync_enter(lock)
        defer { objc_sync_exit(lock) }
        return closure()
    }
}

如果需要返回值，则像这样使用它：

return Sync.syncedReturn(self, closure: {
    // some code here
    return "hello world"
})

或者：

Sync.synced(self, closure: {
    // do some work synchronously
})

Answer 9

您可以使用 GCD。它比@synchronized 稍微冗长一些，但可以作为替代：

let serialQueue = DispatchQueue(label: "com.test.mySerialQueue")
serialQueue.sync {
    // code
}

Answer 10

SWIFT 4

在 Swift 4 中，您可以使用 GCD 调度队列来锁定资源。

class MyObject {
    private var internalState: Int = 0
    private let internalQueue: DispatchQueue = DispatchQueue(label:"LockingQueue") // Serial by default

    var state: Int {
        get {
            return internalQueue.sync { internalState }
        }

        set (newState) {
            internalQueue.sync { internalState = newState }
        }
    }
} 

Answer 11

在 Swift4 中使用 NSLock：

let lock = NSLock()
lock.lock()
if isRunning == true {
        print("Service IS running ==> please wait")
        return
} else {
    print("Service not running")
}
isRunning = true
lock.unlock()

警告 NSLock 类使用 POSIX 线程来实现其锁定行为。当向 NSLock 对象发送解锁消息时，您必须确保该消息是从发送初始锁定消息的同一线程发送的。从不同的线程解锁锁可能会导致未定义的行为。

Answer 12

我自己也在寻找这个，并得出结论，在 swift 中还没有原生结构。

我确实根据我从 Matt Bridges 和其他人那里看到的一些代码编写了这个小辅助函数。

func synced(_ lock: Any, closure: () -> ()) {
    objc_sync_enter(lock)
    closure()
    objc_sync_exit(lock)
}

使用非常简单

synced(self) {
    println("This is a synchronized closure")
}

我发现了一个问题。在这一点上，将数组作为锁定参数传递似乎会导致一个非常迟钝的编译器错误。否则，尽管它似乎可以按预期工作。

Bitcast requires both operands to be pointer or neither
  %26 = bitcast i64 %25 to %objc_object*, !dbg !378
LLVM ERROR: Broken function found, compilation aborted!

Answer 13

Objective-C 中的 @synchronized 指令的模拟可以具有任意返回类型和良好的 rethrows 在 Swift 中的行为。

// Swift 3
func synchronized<T>(_ lock: AnyObject, _ body: () throws -> T) rethrows -> T {
    objc_sync_enter(lock)
    defer { objc_sync_exit(lock) }
    return try body()
}

使用defer 语句可以直接返回一个值，而无需引入临时变量。

---

在 Swift 2 中，将 @noescape 属性添加到闭包以允许更多优化：

// Swift 2
func synchronized<T>(lock: AnyObject, @noescape _ body: () throws -> T) rethrows -> T {
    objc_sync_enter(lock)
    defer { objc_sync_exit(lock) }
    return try body()
}

基于 GNewc [1]（我喜欢任意返回类型）和 Tod Cunningham [2]（我喜欢 defer）的答案。

Answer 14

斯威夫特 3

此代码具有重入能力，可以与异步函数调用一起使用。在此代码中，调用 someAsyncFunc() 后，串行队列上的另一个函数闭包将处理但被 semaphore.wait() 阻塞，直到调用 signal()。不应该使用 internalQueue.sync ，因为如果我没记错的话它会阻塞主线程。

let internalQueue = DispatchQueue(label: "serialQueue")
let semaphore = DispatchSemaphore(value: 1)

internalQueue.async {

    self.semaphore.wait()

    // Critical section

    someAsyncFunc() {

        // Do some work here

        self.semaphore.signal()
    }
}

objc_sync_enter/objc_sync_exit 如果没有错误处理就不是一个好主意。

Answer 15

使用 Bryan McLemore 的答案，我将其扩展为支持使用 Swift 2.0 延迟能力投掷到安全庄园的对象。

func synchronized( lock:AnyObject, block:() throws -> Void ) rethrows
{
    objc_sync_enter(lock)
    defer {
        objc_sync_exit(lock)
    }

    try block()
}

Answer 16

dispatch_barrier_async 是更好的方法，同时不会阻塞当前线程。

dispatch_barrier_async(accessQueue, { 字典[object.ID] = 对象 })

Answer 17

Based on ɲ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

Answer 18

我喜欢并使用这里的许多答案，所以我会选择最适合你的答案。也就是说，当我需要诸如objective-c的@synchronized之类的东西时，我更喜欢使用swift 2中引入的defer语句。

{ 
    objc_sync_enter(lock)
    defer { objc_sync_exit(lock) }

    //
    // code of critical section goes here
    //

} // <-- lock released when this block is exited

这种方法的好处是，您的临界区可以以任何所需的方式退出包含块（例如，return、break、continue、throw），并且“在无论程序控制如何转移，defer 语句都会执行。"1

Answer 19

为什么要让锁变得困难和麻烦？ 使用调度障碍。

调度屏障在并发队列中创建一个同步点。

当它运行时，不允许队列上的其他块运行，即使它是并发的并且其他内核可用。

如果这听起来像是一个排他（写）锁，那就是。 非屏障块可以被认为是共享（读）锁。

只要对资源的所有访问都是通过队列执行的，屏障就可以提供非常便宜的同步。

Answer 20

另一种方法是创建一个超类，然后继承它。这样你可以更直接地使用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
        }
    }

Answer 21

要添加返回功能，您可以这样做：

func synchronize<T>(lockObj: AnyObject!, closure: ()->T) -> T
{
  objc_sync_enter(lockObj)
  var retVal: T = closure()
  objc_sync_exit(lockObj)
  return retVal
}

随后，您可以使用以下方式调用它：

func importantMethod(...) -> Bool {
  return synchronize(self) {
    if(feelLikeReturningTrue) { return true }
    // do other things
    if(feelLikeReturningTrueNow) { return true }
    // more things
    return whatIFeelLike ? true : false
  }
}

Answer 22

您可以将语句夹在objc_sync_enter(obj: AnyObject?) 和objc_sync_exit(obj: AnyObject?) 之间。 @synchronized 关键字在幕后使用了这些方法。即

objc_sync_enter(self)
... synchronized code ...
objc_sync_exit(self)