Wie kann ich überprüfen, dass ich bin läuft auf einem gegebenen GCD Warteschlange, ohne mit dispatch_get_current_queue()?

Vor kurzem hatte ich die Notwendigkeit für eine Funktion, die ich verwenden könnte, um zu garantieren, synchronen Ausführung einer gegebenen block auf einen bestimmten serielle dispatch queue. Es war die Möglichkeit, dass diese gemeinsame Funktion aufgerufen werden könnte, von etwas, das bereits auf die Warteschlange, so dass ich benötigt, um zu überprüfen, für diesen Fall, um zu verhindern, dass ein deadlock von einem synchronen Versand an die gleiche Warteschlange.

Benutzte ich einen code wie den folgenden zu tun:

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

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

Diese Funktion beruht auf der Verwendung von dispatch_get_current_queue() zu bestimmen, die Identität der Warteschlange an diese Funktion ausgeführt wird, und vergleicht dies mit der Ziel-queue. Wenn es eine übereinstimmung gibt, weiß es zu laufen, nur der block inline, ohne die Botschaft an, dass die Warteschlange, da die Funktion bereits ausgeführt wird.

Ich habe gehört, widersprüchliche Dinge darüber, ob oder nicht es war, richtig zu dispatch_get_current_queue() zu tun Vergleiche wie diese, und ich sehe diese Formulierung in den Kopf:

Empfohlen für debugging und Protokollierung nur:

Muss der code keine Annahmen über die Warteschlange zurückgegeben,
es sei denn, es ist einer der globalen Warteschlange oder eine Warteschlange der code hat sich
erstellt. Der code muss nicht davon ausgehen, dass die synchrone Ausführung auf einem
Warteschlange ist sicher von deadlock, wenn die Warteschlange ist nicht die, die durch zurückgegeben
dispatch_get_current_queue().

Darüber hinaus in iOS 6.0 (aber noch nicht für Mountain Lion), den GCD-Header markieren Sie nun diese Funktion als veraltet.

Es klingt wie ich, sollten Sie nicht verwenden diese Funktion in dieser Weise, aber ich bin mir nicht sicher was ich verwenden soll in seinen Platz. Für eine Funktion wie die oben genannten, die gezielt die Haupt-Warteschlange, die ich verwenden könnte [NSThread isMainThread], aber wie kann ich überprüfen, ob ich auf eine meiner benutzerdefinierten serielle Warteschlangen, so kann ich verhindern, dass ein deadlock?

InformationsquelleAutor Brad Larson | 2012-10-09

36

Zuordnen, was Kennung, die Sie wollen mit dispatch_queue_set_specific(). Sie können dann überprüfen Sie Ihre id mit dispatch_get_specific().

Denken Sie daran, dass dispatch_get_specific() ist schön, weil es ' ll start in die aktuelle Warteschlange, und dann zu Fuß bis zum Ziel-Warteschlangen, wenn der Schlüssel nicht gesetzt ist, die auf der aktuellen. Diese in der Regel nicht die Materie, sondern können in einigen Fällen hilfreich sein.
- Ja, das scheint der Weg zu gehen, und ist gesichert durch diese interessante Diskussion über die Apple Developer Foren: devforums.apple.com/message/710745#714753
- Die "zu Fuß bis zum Ziel-Warteschlangen" ist eigentlich ziemlich nützlich hier, wenn Sie einen eindeutigen Schlüssel für die Warteschlange, die Sie versuchen zu schützen (und nicht als ein eindeutiger Wert). So können Sie immer sicher, dass Sie nicht deadlock, wenn Sie Strom auf eine Warteschlange, die Ziele Ihrer video-Warteschlange. Sie können nicht absolut sicher sein, da die Warteschlangen ändern können, Ihre Ziele zu jeder Zeit, so könnte man enqueue-a-block, dann haben einige andere blockieren re-Ziel-Warteschlange auf der video-Warteschlange, bevor der block ausgeführt wird. Also, ähm... tun Sie das nicht. 😀
- Einfach zu verstehen, dass, indem re-entrancy, brechen Sie die FIFO-Garantie der Warteschlange, in die re-entrant-synchrone Aufrufe "springt" die Warteschlange und wird ausgeführt, bevor andere Blöcke sein können, sitzen in der Warteschlange darauf warten, ausgeführt werden.
- ist eine asynchrone barrier-operation, so wird es nicht stattfinden, bis alle Blöcke, die im Moment in der Warteschlange ausgeführt haben.
- wo bekommt man die info? Die docs sagen Sie einfach "Die neue Ziel-queue-Einstellung wird zwischen block-Ausführungen auf das Objekt, aber nicht in der Mitte der vorhandenen block-Ausführungen (non-preemptive)." Es muss aber nicht suggerieren, dass die änderung das Ziel ist, sich als geplanter block. Sie können ändern, auch Ziele, während eine Warteschlange angehalten wird (in der Tat ist dies Häufig der Fall ist), so würde ich wollen, um zu sehen, mehr details über die Punkt dass Sie.
- bezüglich der Reentranz, die synchronen Aufruf wird nicht springen die Warteschlange (das ist unmöglich-by-design). Das problem ist, dass wir aktuell auf Warteschlange A. Wir sagen dann, "planen in diesem block können Sie auf die Warteschlange Ein und warten Sie, bis es zu beenden." Der neue block wird nicht ausgeführt, bis der aktuelle block beendet, und der aktuelle block nicht beenden, bis der neue block beendet. Das ist eine klassische deadlock.
- Sitzung 210 der WWDC 2011 ausdrücklich fest, dass es eine asynchrone Bedienung der schrankenanlage. Gelesen habe ich es auch an anderer Stelle, nur kann mich nicht erinnern aus der Spitze von meinem Kopf, wo. Ein kurzer Blick in die Quelle bestätigt dies - obwohl wir beide wissen, dass wir brauchen, um sein sehr vorsichtig über die Einzelheiten der implementation.
- Notiert. Die Tatsache, dass Sie können ändern Sie diese, während Sie ausgesetzt war, tatsächlich irrelevant. Das ist nützlich (und eine etwas offensichtliche Umsetzung in retrospect). Es bedeutet, dass, wenn Sie eine Warteschlange anhalten, fügen Sie ein paar Blöcke, das Ziel ändern und wieder die Warteschlange, dann sind die Blöcke gehen an das ursprüngliche Ziel. Das ist möglicherweise wichtig, um zu verstehen.
- Bezüglich springen die Warteschlange, können wir Haarspalterei über das, was springen der Warteschlange bedeutet. Aber ich halten, dass, wenn Sie irgendwelche re-entrant-Synchronmechanik, dann alle synchrone Aufrufe (außer dem ersten) muss springen die Warteschlange. Brad ' s original nicht. Ändern Sie pre-queue-Kontext wird als gut. Sie müssen, um Deadlocks zu vermeiden. Sie können dies leicht erkennen, mit dem folgenden Muster: reentrant_sync, dispatch_async, reentrant_sync. Die ersten reentrant_sync wird warten, bis alle in die Warteschlange eingereiht Blöcken ausgeführt. Nachfolgenden, allerdings nicht.
- Jeder block an die Warteschlange übermittelt wurde, egal ob sync oder async, sollte erhalten FIFO-Bestellung. Allerdings, multiple reentrant-sync-Blöcke werden ausgeführt, bevor alle sync-Blöcke, die eingereicht werden, nachdem die anfängliche reentrant-sync startet. Für mich ganz klar "springt" der Warteschlange, weil spätere reentrant-sync-Operationen ausgeführt werden, bevor die zuvor übermittelten Operationen.
- FWIW, gibt es eine Funktion, dispatch_set_current_target_queue dass gilt nicht verwenden Sie eine Barriere blockieren. In der Tat, die header-Datei der Dokumentation für die es sagt, das ist, warum es da ist. Jedoch die header-Datei ist private/queue_private.h so können Sie erraten, Ihre beabsichtigte Verwendung 😉
- Fairer Punkt in der Warteschlange zu springen, aber das ist nicht mein Anliegen hier. Ich bin einfach mit dieser bestimmten seriellen queue als lockless Mittel, um zu verhindern den gleichzeitigen Zugriff auf eine gemeinsam genutzte Ressource (ein OpenGL ES-Kontext, in diesem Fall). Insgesamt ist die Reihenfolge der Ausführung ist nicht ein Problem, so bin ich bereit zu springen die Warteschlange und inline-Operationen, wenn ich bereits in der Mitte der Ausführung eines Blocks auf die gewünschte Warteschlange. Mein primäres Anliegen ist, verhindert den gleichzeitigen Zugriff auf eine gemeinsame Ressource, während die Vermeidung von deadlocks.
- FWIW, das ist der gleiche Ansatz, Core Data nahm. Sie wissen, dass performBlockAndWait hat das exakt gleiche Problem, und es scheint gut genug für Sie...
InformationsquelleAutor Rob Napier

Dies ist eine sehr einfache Lösung. Es ist nicht so performant wie mit dispatch_queue_set_specific und dispatch_get_specific manuell – ich habe nicht die Metriken an.

#import <libkern/OSAtomic.h>

BOOL dispatch_is_on_queue(dispatch_queue_t queue)
{
    int key;
    static int32_t incrementer;
    CFNumberRef value = CFBridgingRetain(@(OSAtomicIncrement32(&incrementer)));
    dispatch_queue_set_specific(queue, &key, value, nil);
    BOOL result = dispatch_get_specific(&key) == value;
    dispatch_queue_set_specific(queue, &key, nil, nil);
    CFRelease(value);
    return result;
}

InformationsquelleAutor hfossli

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.