swift - 等待某个任务完全完成后再执行另一个任务

Question

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

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

但我不知道如何使用 GCD 来正确实现这一点，由于并发问题，显示消息的顺序不正确。但是，我找到了一个解决方案，如果我尝试将 sleep(1) 命令放置到我的代码中，代码会正确运行，但由于 sleep 命令而速度太慢。我尝试了很多方法，但似乎都不正确，除了使用 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")
}

所以你使用它的方式:

1. 初始化组
2. 在开始任务之前输入分组:group.enter()
3. 在每个任务之后放置:group.leave()
4. 将闭包传递给 group.notify。当组任务为空时执行。

注意: 多个 .enter() 需要与 .leave() 匹配