等到某个任务完全完成再执行另一个任务

Question

我正在尝试从 Firebase 实时数据库中检索一些加密消息，对其进行解密，然后将它们显示在 CollectionView 中。解密过程是成功的，但是我遇到了一个关于多线程的问题：将提取的解密消息添加到 Messages 数组的顺序是错误的，所以它们没有以正确的顺序显示在 CollectionView 中，显示消息的顺序在每个运行期间，CollectionView 会有所不同。我认为发生这个问题是因为完成每个加密消息的解密过程所需的时间是不同的，一些加密消息需要更多的时间来解密，而一些加密消息在其他消息之前完成解密，所以它们被添加到 Messages 数组的顺序是不再正确。我期望的工作流程：

向 Firebase 数据库上的消息节点发出获取请求
对于每条提取的消息：
3.1。解密
3.2。将其附加到 Messages 数组
3.3。重新加载 CollectionView 以更新 UI

但我不知道如何使用GCD 来正确实现，显示消息的顺序不正确，因为并发问题。但是，我找到了一个解决方案，如果我尝试将 sleep(1) 命令放置到我的代码中，代码运行是正确的，但由于命令休眠而速度太慢。我尝试了很多方法，但似乎都不对，除了使用 sleep(1) 命令。请帮助我正确地做到这一点，非常感谢！这是我的代码：

func observeMessage(){ 
        self.eThree = VirgilHelper.sharedVirgilHelper.eThreeToUse!

        // Get current user's UID
        guard let uid = FIRAuth.auth()?.currentUser?.uid , let toId = self.user?.id else {
            return;
        }

        let userMessagesRef = FIRDatabase.database().reference().child("user-messages").child(uid).child(toId);
        userMessagesRef.observe(.childAdded, with: { (snapshot) in

            let messageId = snapshot.key;
            let messagesRef = FIRDatabase.database().reference().child("messages").child(messageId);
            // Observe the entire value of that node
            messagesRef.observeSingleEvent(of: .value, with: { (snapshot) in

                if let dictionary = snapshot.value as? [String:AnyObject] {

                //sleep(1) // The working sleep command, but it's too slow

                let message = Message(dictionary: dictionary)
                    if let fromUID = message.fromId, let toUID = message.toId, let cipherText = message.text {

                        self.eThree!.lookupPublicKeys(of: [fromUID], completion: { (lookupResult, error) in
                            if error != nil {
                                print("Error when looking up the Public Key of UID \(fromUID), \(String(describing: error))")
                            }
                            if let lookupResult = lookupResult {
                                message.text = try! self.eThree!.decrypt(text: cipherText, from: lookupResult[fromUID]!)
                                print("text: \(message.text)")

                                // The concurency prolem happens at here
                                self.messages.append(message);

                                // Go back to main thread to update UI
                                DispatchQueue.main.async {
                                    // The concurency prolem happens at here, UI doesn't display with correct order of fetched-decrypted messages
                                    self.collectionView?.reloadData()

                                    let indexPath = IndexPath(item: self.messages.count-1, section: 0)
                                    self.collectionView?.scrollToItem(at: indexPath, at: .bottom, animated: true);
                                }
                            }

                        })
                    }
                }

            }, withCancel: nil)
        }, withCancel: nil)

    }

Answer 1

在 Swift 中，要等待另一个任务完成后再继续其他任务，您可以使用 DispatchQueue.group()。

let group = DispatchGroup()

group.enter()
DispatchQueue.main.async {
    print("1")
    group.leave()
}

group.enter()
DispatchQueue.main.async {
    print("2")
    group.leave()
}

group.enter()
DispatchQueue.main.async {
    print("3")
    group.leave()
}

group.notify(queue: .main) {
    print("Done")
}

所以你的使用方式：

初始化群组
入群方式：group.enter()，开始任务前
在每个任务之后放置：group.leave()
将闭包传递给 group.notify。组任务为空时执行

注意： .enter() 的数量需要与 .leave()

匹配

等到某个任务完全完成再执行另一个任务

Waiting until a certain task completely finish to execute another task

asynchronous

grand-central-dispatch

firebase

swift