【Swift】処理Aが終わったら処理Bを始めたい

Question

前提・実現したいこと

A データベース（CloudKit）のレコードから配列を取得
B 配列に要素を追加
C その配列をデータベースに保存

Aが終わったらB、Bが終わったらC、という処理を書きたいです。

発生している問題

以下の関数を実行しますと、
Aに時間がかかるため、取得前にB、その後すぐCが実行されてしまい、
結果として1つのnewPlanIDだけがデータベースに保存されます。

let publicDatabase = CKContainer.default().publicCloudDatabase

func addPlanIDToDatabase(accountID: String, newPlanID: String) {
            
    var planIDsOnDatabase = [String]()

    // ↓---------- A データベースのレコードから配列を取得 ----------
                
    let recordID = CKRecord.ID(recordName: "accountID-(accountID)")
                
    publicDatabase.fetch(withRecordID: recordID, completionHandler: {(record, error) in
                    
        if let error = error {
            print("予定ID一覧取得エラー: (error)")
            return
        }
                    
        if let planIDs = record?.value(forKey: "planIDs") as? [String] {
                        
            for planID in planIDs {
                planIDsOnDatabase.append(planID)
            }
        } else {
            print("(accountID)のデータベースの予定なし")
        }
    })

    // ↓---------- B 配列に要素を追加 ----------
                
    planIDsOnDatabase.append(newPlanID)

    // ↓---------- C その配列をデータベースに保存 ----------

    let predicate = NSPredicate(format: "accountID == %@", argumentArray: [accountID])
    let query = CKQuery(recordType: "Accounts", predicate: predicate)

    publicDatabase.perform(query, inZoneWith: nil, completionHandler: {(records, error) in
                    
        if let error = error {
            print("(accountID)のデータベースの予定ID追加エラー1: (error)")
            return
        }
                    
        for record in records! {
                        
            record["planIDs"] = planIDsOnDatabase as [String]
                        
            self.publicDatabase.save(record, completionHandler: {(record, error) in
                            
                if let error = error {
                    print("(accountID)のデータベースの予定ID追加エラー2: (error)")
                    return
                }
                            
                print("(accountID)のデータベースの予定ID追加成功")
            })
        }
    })
}

例えばデータベースに"001"があり、そこに"002"を追加して保存したい場合、こんな感じになっています。

理想

A "001"を取得。planIDsOnDatabase = ["001"]
B "002"を追加。planIDsOnDatabase = ["001", "002"]
C planIDsOnDatabase = ["001", "002"]を保存。

現実

A "001"を取得する途中で。planIDsOnDatabase = [String]()
B "002"を追加。planIDsOnDatabase = ["002"]
C planIDsOnDatabase = ["002"]を保存する処理開始。
その後、Aが終わってplanIDsOnDatabase = ["002", "001"]となる。

試したこと

直列処理を書いてみたのですが、知識不足でうまくいきませんでした。

let publicDatabase = CKContainer.default().publicCloudDatabase

func addPlanIDToDatabase(accountID: String, newPlanID: String) {
            
    var planIDsOnDatabase = [String]()

    // ↓---------- A データベースのレコードから配列を取得 ----------

    let dispatchQueue = DispatchQueue(label: "queue")    // 直列キュー
        
    dispatchQueue.async {
            
        let recordID = CKRecord.ID(recordName: "accountID-(accountID)")
                    
        self.publicDatabase.fetch(withRecordID: recordID, completionHandler: {(record, error) in
                        
            if let error = error {
                print("予定ID一覧取得エラー: (error)")
                return
            }
                        
            if let planIDs = record?.value(forKey: "planIDs") as? [String] {
                            
                for planID in planIDs {
                    planIDsOnDatabase.append(planID)
                }
            } else {
                print("(accountID)のデータベースの予定なし")
            }
        })
    }

    // ↓---------- B 配列に要素を追加 ----------
        
    dispatchQueue.async {
        planIDsOnDatabase.append(newPlanID)
    }

    // ↓---------- C その配列をデータベースに保存 ----------
        
    dispatchQueue.async {

        let predicate = NSPredicate(format: "accountID == %@", argumentArray: [accountID])
        let query = CKQuery(recordType: "Accounts", predicate: predicate)
                    
        self.publicDatabase.perform(query, inZoneWith: nil, completionHandler: {(records, error) in
                        
            if let error = error {
                print("(accountID)のデータベースの予定ID追加エラー1: (error)")
                return
            }
                        
            for record in records! {
                            
                record["planIDs"] = planIDsOnDatabase as [String]
                            
                self.publicDatabase.save(record, completionHandler: {(record, error) in
                                
                    if let error = error {
                        print("(accountID)のデータベースの予定ID追加エラー2: (error)")
                        return
                    }
                                
                    print("(accountID)のデータベースの予定ID追加成功")
                })
            }
        })
    }
}

また、Timerで監視して値が変わったら次の処理を……という記述もしてみたのですが、
処理が重くなる上に邪道と思いますので、できれば正当な方法を望みます。

直列処理、もしくは他の正当な手段を知っている方がいらっしゃいましたら、どうぞよろしくお願いいたします。

補足情報（FW/ツールのバージョンなど）

Xcode 11.6
Swift 5

ここまで読んでくださり、ありがとうございます。
質問に至らぬ点があるかもしれませんが、どうぞよろしくお願いいたします。

Answer 1

確かに、試されている方法だと直列キューに入ります。

たとえば、Playgorund で以下のような内容を実行すると、キューに入れた順番通りに処理が実施されます。

import Foundation

// 直列キューを作る
let dispatchQueue = DispatchQueue(label: "queue")

// 直列キューに順番に突っ込む
for i in 1...10 {
    dispatchQueue.async {
        print("((i)) 番目の処理")
    }
}

しかし、質問者である unagimochimochi さんが試されていることは、「反応時間が確約されていない非同期処理」を直列キューに入れていることが、うまいくいかない原因かと思います。

たとえば、非同期処理を直列キューにいれても、処理時間遅れが一定であれば、処理順番はほぼ同じになります。

import Foundation

// 直列キューを作る
let dispatchQueue = DispatchQueue(label: "queue")

// 直列キューに順番に突っ込む内容が一定時間後の処理の場合
for i in 1...10 {
    dispatchQueue.async {
        dispatchQueue.asyncAfter(deadline: .now() + 1.0) {
            print("((i)) 番目の処理")
        }
    }
}

ほぼと書いたのは、時間遅れがある非同期処理は、たとえ時間遅れが全て同じ値に設定したとしても、時間遅れが寸分狂わず同一となる保証はないため、上記の処理も数百回試行するともしかしたら順番通りにならないケースもあるかと思います。

一方、今回試されているケースをモデル化すると、下記のようなパターンになるかと思います。
モデルケースですが、もちろん Playground で実行可能です。

import Foundation

// 直列キューを作る
let dispatchQueue = DispatchQueue(label: "queue")

// 直列キューに順番に突っ込む内容に時間揺らぎがある場合
for i in 1...10 {
    dispatchQueue.async {
        // 時間遅れに揺らぎ(0.5秒から1.0秒の間）を与える
        let delay = Double.random(in: 0.5...1.0)
        dispatchQueue.asyncAfter(deadline: .now() + delay) {
            print("((i)) 番目の処理")
        }
    }
}

上記の例を試してみるとわかりますが、直列キューに入れる内容であっても、その処理が非同期であり、処理時間が確約されないケース（たとえばデータベースへのクエリなど）では、キューに入れる順番と処理の結果が同じになるとは限りません。

では、どのようにして解決すれば良いかというと、結局のところは非同期処理を逐次的に処理するよう、自分でコードを書くしかないかと思います。

たとえば、一つひとつの非同期処理をクロージャを受け取る関数に分け、それを逐次的に処理する方法です。

import Foundation

var planIDsOnDatabase = [String]()

// 非同期処理（1）
func doAsyncProcOne(completion: @escaping () -> ()) {
    print("非同期処理（1）に入りました")
    
    // DB への処理を模擬的に行う
    let delay = Double.random(in: 0.5...1.0)
    DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
        print("非同期処理（1）が完了しました。")
        
        // 文字列を追加する
        // クラス内でのクロージャ処理の場合には、先頭に self. が必要なので注意
        planIDsOnDatabase.append("001")
        
        // 非同期処理完了後の処理を実行する
        completion()
    }
}

// 非同期処理（2）
// 基本形は doAsyncProcOne と同じ。
func doAsyncProcTwo(completion: @escaping () -> ()) {
    print("非同期処理（2）に入りました")
    
    // DB への処理を模擬的に行う
    let delay = Double.random(in: 0.5...1.0)
    DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
        print("非同期処理（2)が完了しました。")
        
        // 文字列を追加する
        // クラス内でのクロージャ処理の場合には、先頭に self. が必要なので注意
        planIDsOnDatabase.append("003")
        
        // 非同期処理完了後の処理を実行する
        completion()
    }
    
}

// 実際の処理
doAsyncProcOne(completion: {
    // 非同期処理（1）終了後の処理
    planIDsOnDatabase.append("002")
    
    // 次の非同期処理をここで呼び
    doAsyncProcTwo(completion: {
        print("---終了処理---")
        // 最後にplanIDsOnDatabase の中身を表示
        for (index, str) in planIDsOnDatabase.enumerated() {
            print("[(index)]", str)
        }
    })
})

最後の「実際の実施」のところで具体的な処理を行いますが、doAsyncProcOne(completion:)で一つ目の処理を行います。

その一つ目の処理が終了した時点で、completion: として渡された処理が行われます。

その中では、次の非同期処理を渡しています。そこでもcompletion: に非同期処理終了後の処理を記述していますので、結果として全ての処理が逐次的に行われるようになっています。

結果として、次のような表示が出るようになっています。

非同期処理（1）に入りました
非同期処理（1）が完了しました。
非同期処理（2）に入りました
非同期処理（2）が完了しました。
---終了処理---
[0] 001
[1] 002
[2] 003

逐次的に呼び出していますので、planIDsOnDatabaseに追加される文字列は順番通りとなっています。

最初は混乱するかもしれませんが、シンプルなパターンに分解して考え、実験してみると少しは分かりやすくなるのではないでしょうか。

Comments

[unagimochimochi]

いつも丁寧なご回答をありがとうございます。
無事、ひとつ目を終えてから次へ、という処理が実行できました。

直列処理はかかる時間が異なる場合は利用は難しそうですね。
クロージャを使った書き方は今まであまり試していませんでしたので、勉強になりました。

ご回答ありがとうございました！