blocchi sincronizzati e dispatch_async

Question

Cosa succede al blocco in IOS utilizzando @synchronized() quando chiamiamo dispatch_async() all'interno del blocco.

Per esempio:

id myID 
-(void) foobar 
{ 
    @synchronized(myID){ 
     dispatch_async(){ //do stuff with myID}; 
    } 
} 

è la serratura ancora valida all'interno della chiamata dispatch_async? O ancora più importante c'è qualche inconveniente nell'usare un'altra chiamata @synchronized() all'interno di dispatch_async()?

Answer 1

Il blocco eviterebbe solo l'invio di due blocchi diversi contemporaneamente. Tuttavia vengono inviati in modo asincrono, quindi possono essere eseguiti in quel momento o possono essere eseguiti arbitrariamente in un lontano futuro. Anche la chiamata di spedizione non aspetterà che si completino.

Quindi la roba all'interno del blocco non è sincronizzata. Le opzioni per raggiungere questo obiettivo con modifiche minime sono una distribuzione sincrona o solo @ sincronizzazione con il blocco.

A seconda di cosa si sta facendo, l'idea migliore potrebbe essere quella di stabilire una coda di invio seriale e inviare i blocchi su quello.

Answer 2

Supponendo che si stia tentando di sincronizzare l'interazione con questo oggetto myID nella coda di sfondo, si desidera il contrario, il blocco all'interno del blocco inviato. In questo momento si dispone di:

@synchronized(myID) { 
    dispatch_async(queue, ^{ 
     // do stuff with myID 
    }); 
} 

Ecco sincronizzare il processo di aggiunta del blocco inviato alla coda, ma lo fa non sincronizzare quello che stai facendo in background. Sospetto che non sia quello che intendevi.

Probabilmente destinato:

dispatch_async(queue, ^{ 
    @synchronized(myID) { 
     // do stuff with myID 
    } 
}); 

Sembra molto simile, ma i risultati in un comportamento completamente diverso. Ora, il lavoro inviato alla coda in background è in fase di sincronizzazione.

Come ulteriore affinamento, se questo inviato blocco è forse lento (e presumo che sia), allora si sarebbe probabilmente per vincolare la @synchronized blocco il più possibile:

dispatch_async(queue, ^{ 

    // do slow stuff in preparation for interacting with `myID` 

    @synchronized(myID) { 
     // quickly do stuff with myID 
    } 

    // do anything else here 
}); 

Se eseguire tutto il blocco in background all'interno di un blocco @synchronized, è possibile annullare l'intero scopo di inviarlo allo sfondo, ovvero minimizzare l'impatto sulla coda principale. Quest'ultima interpretazione mitiga quel problema.

Come osservazione finale, se si dispone di una coda seriale (o di una coda concorrente non globale in cui si esegue l'aggiornamento con una barriera), viene spesso utilizzata come tecnica che elimina del tutto la necessità di serrature, a patto che tutti gli aggiornamenti e le richieste per myID vengono inviati a quella coda. Vedere Eliminating Lock-Based Code nella Guida alla programmazione simultanea .