Swiftでの並行プログラミング：操作

Concurrent Swift Programming：The Basicsでは、Swiftで並行性を制御するための多くの低レベルの方法を紹介しました。 最初のアイデアは、iOSで使用できるさまざまなアプローチをすべて1か所にまとめることでした。 しかし、この記事を書くとき、それらが多すぎて1つの記事にリストできないことに気付きました。 したがって、私はより高いレベルの方法を減らすことにしました。







記事の1つで操作について説明しましたが、詳しく見ていきましょう。

OperationQueue

リコール： 操作は、 GCDに対するCocoaの高レベルの抽象化です。 より正確には、これはdispatch_queue_tの抽象化です。 タスクを追加できるキューと同じ原理を使用します。 OperationQueueの場合、これらのタスクは操作です。 操作を実行するとき、それが開始するスレッドについて知る必要があります。 ユーザーインターフェイスを更新する必要がある場合、開発者はMainOperationQueueを使用する必要があります。

OperationQueue.main
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

それ以外の場合は、プライベートキューを使用できます。

 let operationQueue: OperationQueue = OperationQueue()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

dispatch_queue_tとの違いは、実行する操作の最大数を同時に設定できることです。

 let operationQueue: OperationQueue = OperationQueue() operationQueue.maxConcurrentOperationCount = 1
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

運営

OperationQueueはdispatch_queue_tの高レベルの抽象化であり、操作自体はディスパッチブロックのトップレベルの抽象化と見なされます。 しかし、いくつかの違いがあります。 たとえば、操作には数分以上かかる場合があり、ユニットは数ミリ秒動作します。 オペレーションはクラスであるため、それらを使用してビジネスロジックをカプセル化できます。 したがって、主要なコンポーネント（データベースレベルなど）を変更するには、いくつかの小さな操作を置き換える必要があります。

ライフサイクル

運用中、オペレーションはさまざまな段階を経ます。 キューに追加されると、保留中です。 この状態では、彼女は自分の状態を期待しています。 それらがすべて完了するとすぐに、オペレーションは準備完了状態になり、空きスロットがある場合は実行を開始します。 すべての作業が完了すると、OperationsはFinished状態に入り、OperationQueueから削除されます。 各状態（完了を除く）で操作をキャンセルできます。

キャンセルする

キャンセル操作は非常に簡単です。 キャンセルは、操作によってまったく異なる意味を持つ場合があります。 たとえば、ネットワーク要求を開始するときに、キャンセルするとこの要求が停止する場合があります。 データをインポートするとき、これはトランザクションが拒否されることを意味する場合があります。 この値を割り当てる責任はユーザーにあります。



では、操作をキャンセルする方法は？ .cancel（）メソッドを呼び出すだけです。 これにより、isCancelledプロパティが変更されます。 iOSでできることはこれだけです。 これは、この操作のキャンセルにどのように対応するか、およびさらにどのように動作するかによって異なります。

 let op = DemoOperation() OperationQueue.addOperations([op], waitUntilFinished: false) op.cancel()
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

操作をキャンセルすると、すべての条件がキャンセルされ、できるだけ早くFinished状態に入るようになります。 キューから操作を削除する唯一の方法は、 Finished状態に移行することです。



操作のキャンセルを確認するのを忘れた場合、キャンセルしても、実行されていることがわかります。 また、これは競合状態の影響を受けやすいことに注意してください。 ボタンを押してマークを設定するには、数マイクロ秒かかります。 この間、操作は終了する場合があり、キャンセルマークは無効になります。

準備

準備は、1つのブール値のみで記述されます。 これは、操作の実行準備ができており、起動の順番を待っていることを意味します。 順次キューでは、キューの位置9にある場合もありますが、準備完了状態に入る操作が最初に実行されます。 複数の操作が同時に準備完了状態になった場合、それらの操作が優先されます。 操作は、すべての依存関係が完了した後にのみ準備完了状態になります。

依存関係

これは、操作の真に巨大な機能の1つです。 他のタスクを完了する前に最初に実行する必要があることが示されているタスクを作成できます。 同時に、他のタスクと並行して実行できるタスクがありますが、後続のアクションに依存しています。 これは、.addDependency（）を呼び出すことで実行できます。

 operation2.addDependency(operation1) //execute operation1 before operation2
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

依存関係を持つすべての操作は、すべての依存関係が完了した後、デフォルトで準備完了になります。 ただし、中毒が終了した後の処理方法を決定するのはユーザー次第です。



これにより、業務を厳密に合理化できます。



読みやすいとは思わないので、依存関係を作成するために独自の演算子（==>）を作成しましょう。 したがって、操作の順序を左から右に指定できます。

 precedencegroup OperationChaining { associativity: left } infix operator ==> : OperationChaining @discardableResult func ==><T: Operation>(lhs: T, rhs: T) -> T { rhs.addDependency(lhs) return rhs } operation1 ==> operation2 ==> operation3 // Execute in order 1 to 3
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

依存関係は、異なるOperationQueuesに存在できます。 同時に、予期しないロック動作を引き起こす可能性があります。 たとえば、更新はバックグラウンドでの操作に依存し、他の操作をブロックするため、ユーザーインターフェイスはスローダウンで動作する場合があります。 循環依存関係を覚えておいてください。 これは、操作AがBの操作に依存し、 Bが Aに依存する場合に発生します。 この方法では、両者がお互いに完了することが期待されるため、 デッドロックが発生します。

完了

実行後、Operationは「準備完了」状態に入り、完了ブロックを1回だけ実行します。 完了ブロックは、次のようにインストールできます。

 let op1 = Operation() op1.completionBlock = { print("done") }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

実用例

これらのすべての原則を使用して、操作のための単純な構造を作成しましょう。 操作には、かなり複雑な概念がいくつかあります。 複雑すぎる例を作成する代わりに、「 Hello world 」と入力して、それらのほとんどを含めてみましょう。 この例には、非同期実行、依存関係、および1つと見なされる複数の操作が含まれます。 例を作成してみましょう！

AsyncOperation

最初に、非同期タスクを作成する操作を作成します。 したがって、サブクラスと任意の非同期タスクを作成できます。

 import Foundation class AsyncOperation: Operation { override var isAsynchronous: Bool { return true } var _isFinished: Bool = false override var isFinished: Bool { set { willChangeValue(forKey: "isFinished") _isFinished = newValue didChangeValue(forKey: "isFinished") } get { return _isFinished } } var _isExecuting: Bool = false override var isExecuting: Bool { set { willChangeValue(forKey: "isExecuting") _isExecuting = newValue didChangeValue(forKey: "isExecuting") } get { return _isExecuting } } func execute() { } override func start() { isExecuting = true execute() isExecuting = false isFinished = true } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

かなりいようです。 ご覧のとおり、 isFinishedおよびisExecutingをオーバーライドする必要があります。 さらに、それらの変更はKVOの要件に準拠する必要があります。そうでない場合、 OperationQueueは操作のステータスを監視できません。 start（）メソッドでは、実行の開始からFinished状態に入るまでの操作の状態を制御します。 execute（）メソッドを作成しました。 これは、サブクラスが実装する必要があるメソッドになります。

TextOperation

 import Foundation class TextOperation: AsyncOperation { let text: String init(text: String) { self.text = text } override func execute() { print(text) } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

この場合、印刷するテキストをinit（）に渡し、 execute（）をオーバーライドするだけです。

GroupOperation

GroupOperationは、複数の操作を1つに結合するための実装です。

 import Foundation class GroupOperation: AsyncOperation { let queue = OperationQueue() var operations: [AsyncOperation] = [] override func execute() { print("group started") queue.addOperations(operations, waitUntilFinished: true) print("group done") } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、サブクラスが操作を追加する配列を作成します。 その後、実行時に、プライベートキューに操作を追加するだけです。 したがって、特定の順序で実行されることを保証します。 addOperations（[Operation]、waitUntilFinished：true）メソッドを呼び出すと、追加の操作が実行されるまでキューがブロックされます。 その後、 GroupOperationは状態をFinishに変更します。

HelloWorldオペレーション

独自の操作を作成し、依存関係をインストールして、アレイに追加するだけです。 以上です。

 import Foundation class HelloWorldOperation: GroupOperation { override init() { super.init() let op = TextOperation(text: "Hello") let op2 = TextOperation(text: "World") op2.addDependency(op) operations = [op2, op] } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

操作オブザーバー

では、操作が完了したことをどのようにして知るのでしょうか？ 1つの方法として、competionBlockを追加できます。 もう1つの方法は、OperationObserverを登録することです。 これは、KVOを介してkeyPathにサブスクライブするクラスです。 KVOと互換性がある限り、彼はすべてを監督します。



HelloWorldOperationが終了したらすぐに、小さなフレームワークで「完了」を出力しましょう。

 import Foundation class OperationObserver: NSObject { init(operation: AsyncOperation) { super.init() operation.addObserver(self, forKeyPath: "finished", options: .new, context: nil) } override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) { guard let key = keyPath else { return } switch key { case "finished": print("done") default: print("doing") } } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

データ転送

「Hello World！」の場合、データを送信する意味はありませんが、このケースをすぐに見てみましょう。 最も簡単な方法は、 BlockOperationsを使用することです 。 それらを使用して、データを必要とする次の操作のプロパティを設定できます。 依存関係をインストールすることを忘れないでください、そうでなければ、操作が時間通りに完了しないかもしれません;）

 let op1 = Operation1() let op2 = Operation2() let adapter = BlockOperation() { [unowned op1, unowned op2] in op2.data = op1.data } adapter.addDependency(op1) op2.addDependency(adapter) queue.addOperations([op1, op2, adapter], waitUntilFinished: true)
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

エラー処理

現在考慮していないもう1つのことは、エラー処理です。 実のところ、私はまだこれを行う良い方法を見つけていません。 1つのオプションは、 終了（withErrors :)メソッドへの呼び出しを追加し、各非同期操作がAsyncOperationの代わりに呼び出してstart（）で処理できるようにすることです。 したがって、エラーをチェックして配列に追加できます。 オペレーションBに依存するオペレーションAがあるとします。 突然、操作Bが失敗します。 この場合、操作Aはこの配列を確認し、実行を中止できます。 要件に応じて、エラーを追加できます。



次のようになります。

 class GroupOperation: AsyncOperation { let queue = OperationQueue() var operations: [AsyncOperation] = [] var errors: [Error] = [] override func execute() { print("group started") queue.addOperations(operations, waitUntilFinished: true) print("group done") } func finish(withError errors: [Error]) { self.errors += errors } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

サブ操作はそれに応じて状態を処理する必要があり、そのためにはAsyncOperationにいくつかの変更を加える必要があることに注意してください 。



しかし、いつものように、多くの方法があり、これはそのうちの1つにすぎません。 また、オブザーバーを使用してエラー値を監視することもできます。



どんな方法でも。 完了後に操作が削除されることを確認してください。 たとえば、 CoreDataのコンテキストで記述し 、何か問題が発生した場合、そのコンテキストをクリアする必要があります。 そうでない場合、未定義の状態になる可能性があります。

UI操作

操作は、表示されていない項目に限定されません。 アプリケーションで行うすべての操作を実行できます（ただし、実行しないことをお勧めします）。 しかし、オペレーションとして見やすいものがいくつかあります。 モーダルなものはすべて、それに応じて検討する必要があります。 ダイアログを表示する操作を見てみましょう。

 import Foundation class UIOperation: AsyncOperation { let viewController: UIViewcontroller! override func execute() { let alert = UIAlertController(title: "My Alert", message: @"This is an alert.", preferredStyle: .alert) alert.addAction(UIAlertAction(title: "OK", style: .`default`, handler: { _ in self.handleInput() })) viewController.present(alert, animated: true, completion: nil) } func handleInput() { //do something and continue operation } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、ボタンが押されるまで実行を一時停止します。 その後、彼女は完了状態に入り、これに依存する他のすべての操作を続行できます。

UI操作

操作は、表示されていない項目に限定されません。 アプリケーションで行うすべての操作を実行できます（ただし、実行しないことをお勧めします）。 しかし、オペレーションとして見やすいものがいくつかあります。 モーダルなものはすべて、それに応じて検討する必要があります。 ダイアログを表示する操作を見てみましょう。

 import Foundation class UIOperation: AsyncOperation { let viewController: UIViewcontroller! override func execute() { let alert = UIAlertController(title: "My Alert", message: @"This is an alert.", preferredStyle: .alert) alert.addAction(UIAlertAction(title: "OK", style: .`default`, handler: { _ in self.handleInput() })) viewController.present(alert, animated: true, completion: nil) } func handleInput() { //do something and continue operation } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

ご覧のとおり、ボタンが押されるまで実行を一時停止します。 その後、彼女は完了状態に入り、これに依存する他のすべての操作を続行できます。

相互排除

ユーザーインターフェイスに操作を使用できる場合、別のタスクが表示されます。 エラーに関するダイアログが表示されると想像してください。 ネットワークが利用できないときにエラーを表示するいくつかの操作をキューに追加している可能性があります。 これにより、警告が表示されたときに、前述のすべての操作がネットワーク接続の切断につながる可能性があるという事実に簡単につながる可能性があります。 その結果、複数のダイアログが同時に表示されますが、どちらが最初でどちらが2番目かはわかりません。 したがって、これらのダイアログを相互に排他的にする必要があります。



アイデア自体が複雑であるという事実にもかかわらず、依存関係を使用して実装するのはかなり簡単です。 これらのダイアログ間に依存関係を作成するだけで完了です。 1つの問題は、操作の追跡です。 ただし、これは名前付け操作を使用して解決でき、 OperationQueueにアクセスして名前を検索します。 この方法では、リンクを保持する必要はありません。

 let op1 = Operation() op1.name = "Operation1" OperationQueue.main.addOperations([op1], waitUntilFinished:false) let operations = OperationQueue.main.operations operations.map { op in if op.name == "Operation1" { op.cancel() } }
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

おわりに

操作は優れた同時実行性ツールです。 だまされてはいけません、彼らはあなたが思うより難しいです。 私は現在、運用に基づいたプロジェクトをサポートしていますが、その一部は非常に複雑で、作業が不便です。 特に、エラー処理中に多くの障害が発生します。 グループ操作を実行するたびに、正しく実行されない場合は、複数のエラーが発生する可能性があります。 特定の種類の必要なエラーを取得するには、それらをフィルタリングする必要があるため、表示ルーチンのためにエラーが混乱する場合があります。



別の問題は、起こりうる並列の同一の問題について考えるのをやめることです。 これらの詳細についてはまだ話していませんが、上記のエラー処理コードでGroupOperationsについて覚えています。 将来の投稿で修正されるバグが含まれています。



操作は、優れた同時実行管理ツールです。 GCDはまだ注文されていません。 スレッドの切り替えや、できるだけ早く完了する必要があるタスクなどの小さなタスクの場合、操作を使用したくない場合があります。 これに対する理想的なソリューションはGCDです。