Differenza tra l'invio a una coda con `sync` e l'utilizzo di un oggetto di lavoro con un flag` .wait`?

Question

Sto imparando a conoscere GCD di Apple e guardando il video Concurrent Programming With GCD in Swift 3.

Alle 16:00 in questo video, viene descritta una bandiera per DispatchWorkItem chiamata .wait, e la funzionalità e il diagramma mostrano entrambi esattamente quello che pensavo fosse lo myQueue.sync(execute:).

Quindi, la mia domanda è; qual è la differenza tra:

myQueue.sync { sleep(1); print("sync") } 

E:

myQueue.async(flags: .wait) { sleep(1); print("wait") } 
// NOTE: This syntax doesn't compile, I'm not sure where the `.wait` flag moved to. 
// `.wait` Seems not to be in the DispatchWorkItemFlags enum. 

Sembra come entrambi gli approcci bloccano il thread corrente mentre aspettano per la coda denominata a:

1. Fine ogni attuale o prima lavoro (se seriale)
2. Completare il blocco dato/oggetto di lavoro

La mia comprensione di questo deve essere fuori da qualche parte, cosa mi manca?

Answer 1

.wait è non una bandiera DispatchWorkItemFlags, ed è per questo il codice

myQueue.async(flags: .wait) { sleep(1); print("wait") } 

non viene compilato.

wait() is a method of DispatchWorkItem e solo un wrapper per dispatch_block_wait().

/*! 
* @function dispatch_block_wait 
* 
* @abstract 
* Wait synchronously until execution of the specified dispatch block object has 
* completed or until the specified timeout has elapsed. 

semplice esempio:

let myQueue = DispatchQueue(label: "my.queue", attributes: .concurrent) 
let workItem = DispatchWorkItem { 
    sleep(1) 
    print("done") 
} 
myQueue.async(execute: workItem) 
print("before waiting") 
workItem.wait() 
print("after waiting") 

dispatchMain()