Swift 3 GCD 和解析

Question

我对如何实现这一点感到困惑。

我想调用一个函数 (func1)，该函数将调用 func2，后者执行一些 Parse 查询并将它们提交到数据库。

一旦所有这些查询都完成并且 func2 完全完成运行ning 我想运行 func3 将执行类似的任务。

我想在 func3 完全完成后更新我的 tableView 运行ning 但我在使用 GCD 时运气不好。

我的问题是当我调用 func1() 然后等待组完成时，tableview 重新加载数据函数在执行 func3 之前执行。

解决这个问题的最佳方法是什么？

 let group = DispatchGroup()
 let queue1 = DispatchQueue()
 let queue2 = DispatchQueue() 
 let queue3 = DispatchQueue()

 func1(){
     queue1.async(group: group){
        for i in 0...10 {
            func2(i)
        }
     }

     group.notify(queue: queue2){
        func3()
     }
 }

 func2(i: Int){
      queue2.async(group: group){
           // Perform query for value i
           PFQuery.findObjectsInBackground {}
      }
 }


func3(){
     queue3.async(group: group){
        PFQuery.findObjectsInBackground {}
     }
}


func1()
group.notify(queue: queue4){
    tableView.reloadData()
}

简化：

func1() 在 for 循环中多次调用 func2()。
所有 func2() 调用必须在 func3() 开始之前完成
func3() 必须在 tableview 重新加载之前完成。

Answer 1

func func1() {

    // Call func 2 and give it a block of work to execute when it is done
    func2(completionHandler: {
        // call func3 and give it a block of work to do when it is done
        func3(completionHandler: {
            // call back to the main thread to update the table
            update_my_table()
        }
    })
}

func func2(completionHandler: () -> void) {
    PFQuery.findObjectsInBackground()

    ... other work that must be done before func3 ...

    // execute work that should be done when func2 completes
    completionHandler()
}

func func3(completionHandler: () -> void) {
    ... do some stuff to prepare table data ...

    // execute work that must be done when func 3 completes
    completionHandler()
}

func update_my_table() {
    DispatchQueue.main.async {
        tableView.reloadData()
    }
}

Answer 2

您是否应该创建一个类似于所有异步计算组合的方法。这使您可以轻松控制。是的，您应该仅在最后一次通话后调用通知。

func func1(){
  queue1.async(group: group){
    print("Some work in background queue 1")
  }
}

func  func2(){
  queue2.async(group: group){
    print("Some work in background queue 2")
  }
}


func func3(){
  group.notify(queue: queue3) {
    print("Some work in background queue 3")
  }
}


func doCompositeOperations() {
  func1()
  func2()
  DispatchQueue.main.async(group: group) {
    print("Reloading after all")
  }

  func3()
}

doCompositeOperations()

我认为 func1、func2 func3 ... 也在它自己的队列中执行一些异步操作，returns 在完成处理程序中返回结果。在这种情况下，我更喜欢 enter 和 leave 调度组的变体，这样你可以更好地控制。

Answer 3

根据以下信息，这是我的第一次尝试：

func1() calls func2() several times in a for loop.

all of the func2() calls must finish before func3() begins

func3() must finish before tableview can reload.

func1() {
    let group = DispatchGroup()

    for element in elements {
        group.enter()
        func2(element, completion: { group.leave() })
    }

    group.await()

    func3(completion: {tableview.reload() })
}

Swift 3 GCD 和解析

Swift 3 GCD and Parse

asynchronous

parse-platform

swift