swift – 试图理解异步操作子类

1. What is the purpose of the stateQueue property? I see it being used by get and set of the state computed property,but I can’t find any documentation that explains the sync:flags:execute and sync:execute methods that they use.

此代码“同步”对属性的访问以使其线程安全.关于为什么需要这样做,请参阅the Operation documentation,其中建议：

Multicore Considerations

… When you subclass NSOperation,you must make sure that any overridden methods remain safe to call from multiple threads. If you implement custom methods in your subclass,such as custom data accessors,you must also make sure those methods are thread-safe. Thus,access to any data variables in the operation must be synchronized to prevent potential data corruption. For more information about synchronization,see 07001.

关于这个并发队列用于同步的确切用法,这被称为“读写器”模式.读写器模式的这个基本概念是读取可以相互发生并发(因此同步,没有障碍),但写入必须永远不会同时执行该属性的任何其他访问(因此与屏障异步) .这一点在WWDC 2012视频Asynchronous Design Patterns with Blocks,GCD,and XPC中有所描述.注意,虽然该视频概述了基本概念,但它使用了较旧的dispatch_sync和dispatch_barrier_async语法,而不是使用了同步和同步(flags：.barrier)语法的Swift 3及更高版本语法这里.

你还问：

2. What is the purpose of the three class methods in the NSObject section that return ["state"]? I don’t see them being used anywhere. I found,in NSObject,class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String>,but that doesn’t seem to help me understand why these methods are declared.

这些只是确保状态属性更改触发属性isReady,isExecuting和isFinished的KVN的方法.这三个键的KVN对于异步操作的正确运行至关重要.无论如何,这种语法在Key-Value Observing Programming Guide: Registering Dependent Keys中概述.

您找到的keyPathsForValuesAffectingValue方法是相关的.您可以使用该方法注册从属密钥,也可以使用原始代码段中显示的各个方法.

顺便说一句,这是您提供的AsynchronousOperation类的修订版,即：

>你不能调用super.start().正如start documentation所说(重点补充)：

If you are implementing a concurrent operation,you must override this method and use it to initiate your operation. Your custom implementation must not call super at any time.

>在Swift 4中添加@objc.
>重命名execute以使用main,这是Operation子类的约定.
>将isReady声明为最终属性是不合适的.任何子类都应该有权进一步细化其isReady逻辑(尽管我们很少这样做).
>使用#keyPath使代码更安全/健壮.
>使用动态属性时,不需要手动KVN.在此示例中不需要手动调用willChangeValue和didChangeValue.
>更改完成,以便只有isExecuting才会移动到.finished状态.

从而：

public class AsynchronousOperation: Operation {

    /// State for this operation.

    @objc private enum OperationState: Int {
        case ready
        case executing
        case finished
    }

    /// Concurrent queue for synchronizing access to `state`.

    private let stateQueue = DispatchQueue(label: Bundle.main.bundleIdentifier! + ".rw.state",attributes: .concurrent)

    /// Private backing stored property for `state`.

    private var _state: OperationState = .ready

    /// The state of the operation

    @objc private dynamic var state: OperationState {
        get { return stateQueue.sync { _state } }
        set { stateQueue.sync(flags: .barrier) { _state = newValue } }
    }

    // MARK: - Various `Operation` properties

    open         override var isReady:        Bool { return state == .ready && super.isReady }
    public final override var isExecuting:    Bool { return state == .executing }
    public final override var isFinished:     Bool { return state == .finished }

    // KVN for dependent properties

    open override class func keyPathsForValuesAffectingValue(forKey key: String) -> Set<String> {
        if ["isReady","isFinished","isExecuting"].contains(key) {
            return [#keyPath(state)]
        }

        return super.keyPathsForValuesAffectingValue(forKey: key)
    }

    // Start

    public final override func start() {
        if isCancelled {
            finish()
            return
        }

        state = .executing

        main()
    }

    /// Subclasses must implement this to perform their work and they must not call `super`. The default implementation of this function throws an exception.

    open override func main() {
        fatalError("Subclasses must implement `main`.")
    }

    /// Call this function to finish an operation that is currently executing

    public final func finish() {
        if isExecuting { state = .finished }
    }
}