GCD per eseguire attività nel thread principale

Ho un callback che potrebbe provenire da qualsiasi thread. Quando ricevo questo callback, vorrei eseguire una determinata attività sul thread principale.

Devo verificare se sono già sul thread principale - o c'è qualche penalità non eseguendo questo controllo prima di chiamare il codice qui sotto?

dispatch_async(dispatch_get_main_queue(), ^{
   // do work here
});

No, non è necessario verificare se si è già nel thread principale. Inviando il blocco alla coda principale, si sta semplicemente programmando che il blocco venga eseguito in serie sul thread principale, cosa che accade quando viene eseguito il ciclo di esecuzione corrispondente.

Se sei già sul thread principale, il comportamento è lo stesso: il blocco è programmato ed eseguito quando viene eseguito il ciclo di esecuzione del thread principale.

Per il caso di spedizione asincrono descritto sopra, non dovresti controllare se sei nel thread principale. Come Bavarous indica, questo sarà semplicemente messo in coda per essere eseguito sul thread principale.

Tuttavia, se si tenta di eseguire quanto sopra utilizzando a dispatch_sync()e il callback si trova sul thread principale, l'applicazione si bloccherà a quel punto. Lo descrivo nella mia risposta qui , perché questo comportamento mi ha sorpreso quando ho spostato del codice da -performSelectorOnMainThread:. Come ho già detto, ho creato una funzione di supporto:

void runOnMainQueueWithoutDeadlocking(void (^block)(void))
{
    if ([NSThread isMainThread])
    {
        block();
    }
    else
    {
        dispatch_sync(dispatch_get_main_queue(), block);
    }
}

che eseguirà un blocco in modo sincrono sul thread principale se il metodo in cui ti trovi non è attualmente sul thread principale e, se lo è, esegue il blocco in linea. È possibile utilizzare la sintassi come la seguente per utilizzare questo:

runOnMainQueueWithoutDeadlocking(^{
    //Do stuff
});

Come menzionato nelle altre risposte, dispatch_async dal thread principale va bene.

Tuttavia, a seconda del caso d'uso, c'è un effetto collaterale che potresti considerare uno svantaggio: poiché il blocco è programmato su una coda, non verrà eseguito fino a quando il controllo non tornerà al ciclo di esecuzione, che avrà l'effetto di ritardare l'esecuzione del tuo blocco.

Per esempio,

NSLog(@"before dispatch async");
dispatch_async(dispatch_get_main_queue(), ^{
    NSLog(@"inside dispatch async block main thread from main thread");
});
NSLog(@"after dispatch async");

Stampa:

before dispatch async
after dispatch async
inside dispatch async block main thread from main thread

Per questo motivo, se ti aspettavi che il blocco venisse eseguito tra i NSLog esterni, dispatch_async non ti sarebbe d'aiuto.

No, non è necessario verificare se si è nel thread principale. Ecco come puoi farlo in Swift:

runThisInMainThread { () -> Void in
    runThisInMainThread { () -> Void in
        // No problem
    }
}

func runThisInMainThread(block: dispatch_block_t) {
    dispatch_async(dispatch_get_main_queue(), block)
}

È incluso come funzione standard nel mio repository, provalo: https://github.com/goktugyil/EZSwiftExtensions