Recentemente, tive a necessidade de uma função que eu pudesse usar para garantir a execução síncrona de um determinado bloco em uma fila de despacho serial específica. Havia a possibilidade de que essa função compartilhada pudesse ser chamada de algo que já estava em execução nessa fila, então eu precisava verificar esse caso para evitar um impasse de um envio síncrono para a mesma fila.

Eu usei o código como o seguinte para fazer isso:

void runSynchronouslyOnVideoProcessingQueue(void (^block)(void))
{
    dispatch_queue_t videoProcessingQueue = [GPUImageOpenGLESContext sharedOpenGLESQueue];

    if (dispatch_get_current_queue() == videoProcessingQueue)
    {
        block();
    }
    else
    {
        dispatch_sync(videoProcessingQueue, block);
    }
}

Esta função depende do uso dedispatch_get_current_queue() para determinar a identidade da fila em que esta função está sendo executada e compara-a com a fila de destino. Se houver uma correspondência, ela saberá apenas executar o bloco inline sem o dispatch para essa fila, porque a função já está em execução nela.

Eu ouvi coisas conflitantes sobre se era ou não apropriado usardispatch_get_current_queue() para fazer comparações como essa, e vejo essa redação nos cabeçalhos:

Recomendado apenas para fins de depuração e registro:

O código não deve fazer suposições sobre a fila retornada, a menos que seja uma das filas globais ou uma fila que o código tenha criado. O código não deve presumir que a execução síncrona em uma fila é segura contra impasse se essa fila não for aquela retornada por dispatch_get_current_queue ().

Além disso, no iOS 6.0 (mas ainda não no Mountain Lion), os cabeçalhos do GCD agora marcam essa função como obsoleta.

Parece que eu não deveria estar usando essa função dessa maneira, mas não tenho certeza do que devo usar em seu lugar. Para uma função como a acima, que visava a fila principal, eu poderia usar[NSThread isMainThread], mas como posso verificar se estou executando em uma das minhas filas seriais personalizadas para que eu possa evitar um deadlock?