如何在Swift中处理组等待结果3

Question

我正在尝试下面的代码在操场上，但它似乎没有按照我的预期工作。

两个group_async操作总共导致我的Mac上约5秒到6秒。

• 当我将超时时间设置为DispatchTime.now（）+ 10时，会同时打印“测试返回”和“完成”。
• 当我将超时时间设置为DispatchTime.now（）+ 1（某些值使组超时）时，除了两个group_async操作中的打印代码外，不会打印任何内容。

我想要的是暂停组并在超时时做一些清理工作，并在组成功完成时进行其他一些操作。任何建议表示赞赏。谢谢。

import Dispatch 
import PlaygroundSupport 

PlaygroundPage.current.needsIndefiniteExecution = true 
let queue = DispatchQueue.global(qos: .utility) 

func test() { 
    let group = DispatchGroup() 
    __dispatch_group_async(group, queue) { 
     var a = [String]() 
     for i in 1...999 { 
      a.append(String(i)) 
      print("appending array a...") 
     } 
     print("a finished") 
    } 

    __dispatch_group_async(group, queue) { 
     var b = [String]() 
     for i in 1...999 { 
      b.append(String(i)) 
      print("appending array b...") 
     } 
     print("b finished") 
    } 

    let result = group.wait(timeout: DispatchTime.now() + 10) 
    if result == .timedOut { 
     group.suspend() 
     print("timed out") 
    } 
    print("test returns") 
} 


queue.async { 
    test() 
    print("done") 
} 

Answer 1

此代码段提出了各种不同的问题：

1. 我注意到，行为不同操场之间的一点，当你在一个应用程序中运行它。我怀疑这是needsIndefiniteExecution的PlaygroundPage和GCD的一些特质。我建议在一个应用中测试这个。有了我在下面提出的要点的警告，当我从应用程序运行此应用程序时，它会按预期工作。

2. 我注意到你已经采用了这样的模式：

   __dispatch_group_async(group, queue) { 
       ... 
   } 
   

   我建议：

   queue.async(group: group) { 
       ... 
   } 
   

3. 你正在做group.suspend()。几个注意事项：

   • 一个挂起队列，而不是组。

   • 如果您曾打电话suspend()，请确保您有相应的电话resume()某处。

   • 此外，请记住，suspend()停止启动未来的块，但它不会对可能已在运行的块执行任何操作。如果你想停止已经运行的块，你可能想要取消它们。

   • 最后，请注意，您只能暂停您创建的队列和来源。你不能（也不应该）暂停一个全局队列。

4. 我也注意到，你在你派出test()调用同一个队列使用wait。在这种情况下，由于它是一个并发队列，所以你会越来越远，但这种模式会导致死锁。如果可以的话，我建议完全避免wait，并且肯定不要在你调用它的同一个队列上进行。再一次，这里不是问题，但是这种模式可能会在未来让你陷入困境。

   就个人而言，我可能倾向于使用notify而不是wait触发代码块在两个调度块完成时运行。这消除了任何死锁风险。如果我想要一段代码在一段时间后运行（即超时过程），我可能会使用计时器触发某些清理过程，以防这两个块仍在运行（可能取消它们;请参阅How to stop a DispatchWorkItem in GCD? ）。

Answer 2

@Rob对每个点都有非常好的细节建议。我注意到，当我用Rob的笔记调整Evan的代码时，它似乎在Playground中起作用。我没有在应用程序中测试过。注意如何在测试函数之外声明组，以便稍后我们可以调用group.notify，我们可以在其中调用PlaygroundPage的finishExcution（）。另外请注意，DispatchGroup的通知功能是在提交的任务对象完成后执行任何额外工作的好方法。在操场上，我们称之为通知：

import Foundation 
import PlaygroundSupport 
PlaygroundPage.current.needsIndefiniteExecution = true 

let queue = DispatchQueue.global(qos: .utility) 
let group = DispatchGroup() 

func test() { 
     queue.async(group: group) { 
     var a = [String]() 
     for i in 1...999 { 
      a.append(String(i)) 
      print("appending array a...") 
     } 
     print("a finished") 
     } 
     queue.async(group: group){ 
     var b = [String]() 
     for i in 1...999 { 
      b.append(String(i)) 
      print("appending array b...") 
     } 
     print("b finished") 
     } 

    DispatchQueue.global().asyncAfter(deadline: DispatchTime.now() + 0.01) { 
     print("doing clean up in timeout") 
    } 


} 

test() 
print("done") 

group.notify(queue: DispatchQueue.global()) { 
    print("work completed") 
    PlaygroundPage.current.finishExecution() 
} 

Answer 3

只是为了比较不同的方法试试这个在您的游乐场

import Foundation 

func test(timeout: Double) { 
    let queue = DispatchQueue(label: "test", attributes: .concurrent) 
    let group = DispatchGroup() 
    var stop = false 
    let delay = timeout 

    queue.async(group: group) { 
     var str = [String]() 
     var i = 0 
     while i < 1000 && !stop{ 
      str.append(String(i)) 
      i += 1 
     } 

     print(1, "did", i, "iterations") 
    } 
    queue.async(group: group) { 
     var str = [String]() 
     var i = 0 
     while i < 2000 && !stop{ 
      str.append(String(i)) 
      i += 1 
     } 

     print(2, "did", i, "iterations") 
    } 
    queue.async(group: group) { 
     var str = [String]() 
     var i = 0 
     while i < 100 && !stop{ 
      str.append(String(i)) 
      i += 1 
     } 

     print(3, "did", i, "iterations") 
    } 
    queue.async(group: group) { 
     var str = [String]() 
     var i = 0 
     while i < 200 && !stop{ 
      str.append(String(i)) 
      i += 1 
     } 

     print(4, "did", i, "iterations") 
    } 
    group.wait(wallTimeout: .now() + delay) 
    stop = true 
    queue.sync(flags: .barrier) {} // to be sure there are no more jobs in my queue 
} 

var start = Date() 
test(timeout: 25.0) 
print("test done in", Date().timeIntervalSince(start), "from max 25.0 seconds") 
print() 
start = Date() 
test(timeout: 5.0) 
print("test done in", Date().timeIntervalSince(start), "from max 5.0 seconds") 

它打印（在我的环境）

3 did 100 iterations 
4 did 200 iterations 
1 did 1000 iterations 
2 did 2000 iterations 
test done in 17.7016019821167 from max 25.0 seconds 

3 did 100 iterations 
4 did 200 iterations 
2 did 697 iterations 
1 did 716 iterations 
test done in 5.00799399614334 from max 5.0 seconds