dispatch_async vs ordine di esecuzione dispatch_sync

Question

ho una coda di invio di serie creata con:

dispatch_queue_t serialQueue = dispatch_queue_create("com.unique.name.queue", DISPATCH_QUEUE_SERIAL); 

voglio usare questa coda di serie per garantire la sicurezza dei thread per l'accesso di classe, mentre si fa automaticamente il lavoro in modo asincrono che non ha bisogno di ritorna al thread chiamante.

- (void)addObjectToQueue:(id)object 
{ 
    dispatch_async(serialQueue, ^{ 
     // process object and add to queue 
    }); 
} 

- (BOOL)isObjectInQueue:(id)object 
{ 
    __block BOOL returnValue = NO; 
    dispatch_sync(serialQueue, ^{ 
     // work out return value 
    }); 
    return returnValue; 
} 

Se chiamo l'addObjectToQueue: metodo, poi subito chiamare l'isObjectInQueue: metodo, essi sono garantiti per essere eseguito nello stesso ordine, o lo/la potevano isObjectInQueue eseguire per primo?

In altre parole, dispatch_async esegue esattamente lo stesso di dispatch_sync (pianificando immediatamente il blocco) eccetto che non blocca il thread chiamante?

Ho visto domande simili con risposte andando in entrambe le direzioni, quindi sto cercando una risposta definitiva, preferibilmente supportata dalla documentazione Apple.

Answer 1

Sono garantiti per essere eseguiti nello stesso ordine?

Sì.

Will/could isObjectInQueue esegue prima?

Sì.

Il motivo del sì per entrambe le risposte è che è necessario considerare il threading. Il che è presumibilmente il motivo per cui stai usando la coda seriale in primo luogo. Stai rendendo sicuro l'accesso a quel thread delle code.

Fondamentalmente, i blocchi verranno eseguiti nell'ordine in cui vengono inseriti nella coda seriale. Questo è garantito al 100%. Tuttavia, se più thread vengono eliminati, allora un thread potrebbe entrare per primo a leggere qualcosa dalla coda prima che un altro abbia avuto la possibilità di aggiungerlo.

In altre parole, fa dispatch_async eseguire esattamente lo stesso come dispatch_sync (programmando il blocco immediatamente) tranne che non blocca il thread chiamante?

Proprio così. In entrambi i casi il blocco viene aggiunto alla coda. Viene aggiunto immediatamente. dispatch_sync aspetta che il blocco termini prima di tornare, mentre dispatch_async restituisce immediatamente.

Answer 2

Immagino che la tua domanda sia, il thread principale continuerà a funzionare mentre dispatch_async sta ancora eseguendo l'operazione di coda? Presumo che non lo farà, perché meriterebbe una menzione esplicita. Se non altro, ho trovato questo in dispatch_async.3 che suggerisce questo è il caso:

Concettualmente, dispatch_sync() è un wrapper conveniente intorno dispatch_async() con l'aggiunta di un semaforo di attesa per il completamento del blocco, e un wrapper attorno al blocco per segnalare il completamento di .

E in effetti, se si segue il codice sorgente per dispatch_async in queue.c vedrete che il blocco è in coda in primo piano, e solo dopo che, l'esecuzione ritorna al codice che chiama dispatch_async. Pertanto se la coda è seriale, dispatch_async seguita da dispatch_syncdallo stesso thread verranno messi in coda i blocchi in ordine.

Perché dispatch_sync bloccherà fino a quando il blocco (e tutti i blocchi precedenti in una coda seriale) saranno eseguiti, quindi il codice sarebbe corretto. isObjectInQueue: segnalerà correttamente se l'oggetto aggiunto prima è in coda.

modifica: in un ambiente con multithreading avrei scritto il codice precedente come:

- (void)addObjectToQueue:(id)object 
{ 
    dispatch_barrier_async(_queue, ^{ 
     // process object and add to queue 
    }); 
} 

- (BOOL)isObjectInQueue:(id)object 
{ 
    __block BOOL returnValue = NO; 
    dispatch_sync(_queue, ^{ 
     // work out return value 
    }); 
    return returnValue; 
} 

perché l'esecuzione di ogni metodo può essere differito in qualsiasi punto a favore di un altro filo.