Wie der Versand über die main queue synchron, ohne einen deadlock?

Muss ich Versand Sie einen block auf der main queue synchron. Ich weiß nicht, ob ich bin derzeit auf der main-thread oder nicht. Die naive Lösung sieht wie folgt aus:

dispatch_sync(dispatch_get_main_queue(), block);

Aber wenn ich derzeit innerhalb eines Blocks ausgeführt, die auf das Haupt-queue, dieser Aufruf erzeugt eine Sackgasse. (Die synchron-Versand wartet, bis der block zu Ende, aber der block nicht auch noch anfangen zu laufen, da warten wir auf die aktuellen zu beenden.)

Den offensichtlichen nächsten Schritt ist zu prüfen, für die aktuelle Warteschlange:

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

Dies funktioniert, aber es ist hässlich. Bevor ich zumindest verstecken Sie sich hinter ein paar benutzerdefinierte Funktion, gibt es nicht eine bessere Lösung für dieses problem? Ich betone, dass ich nicht leisten können, den Versand der block asynchron – die app ist in einer situation, wo die asynchron wird ausgelöst, blockieren würde, die ausgeführt werden, "zu spät".

InformationsquelleAutor der Frage zoul | 2012-04-26

  1. 65

    Muss ich so etwas wie das ziemlich regelmäßig in meiner Mac-und iOS-Anwendungen, so dass ich mit der folgenden Hilfsfunktion (ursprünglich beschrieben in diese Antwort):

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

    die Sie nennen, über 

    runOnMainQueueWithoutDeadlocking(^{
    //Do stuff
});

    Ist dies ziemlich genau der Prozess, den Sie oben beschreiben, und ich habe einige andere Entwickler, die unabhängig voneinander gestaltete so etwas für sich selbst.

    Ich verwendet [NSThread isMainThread] statt Kontrolle dispatch_get_current_queue()weil die Vorsichtsmaßnahmen Abschnitt für diese Funktion einmal gewarnt, vor der Verwendung dieses für die Identität testen und der Anruf war veraltet in iOS 6.

    InformationsquelleAutor der Antwort Brad Larson

  2. 1

    Für die Synchronisierung auf dem main-Warteschlange oder auf den Haupt-thread (das ist nicht das gleiche), die ich benutze:

    import Foundation

private let mainQueueKey    = UnsafeMutablePointer<Void>.alloc(1)
private let mainQueueValue  = UnsafeMutablePointer<Void>.alloc(1)


public func dispatch_sync_on_main_queue(block: () -> Void)
{
    struct dispatchonce  { static var token : dispatch_once_t = 0  }
    dispatch_once(&dispatchonce.token,
    {
        dispatch_queue_set_specific(dispatch_get_main_queue(), mainQueueKey, mainQueueValue, nil)
    })

    if dispatch_get_specific(mainQueueKey) == mainQueueValue
    {
        block()
    }
    else
    {
        dispatch_sync(dispatch_get_main_queue(),block)
    }
}

extension NSThread
{
    public class func runBlockOnMainThread(block: () -> Void )
    {
        if NSThread.isMainThread()
        {
            block()
        }
        else
        {
            dispatch_sync(dispatch_get_main_queue(),block)
        }
    }

    public class func runBlockOnMainQueue(block: () -> Void)
    {
        dispatch_sync_on_main_queue(block)
    }
}

    InformationsquelleAutor der Antwort JollyJinx

  3. 0

    Habe ich vor kurzem erlebt begann ein deadlock während der UI-updates. Das führt mich dieser Stack Overflow Frage, die mir die Umsetzung ein runOnMainQueueWithoutDeadlocking-Art Helfer-Funktion auf der Grundlage der akzeptierten Antworten.

    Das wirkliche Problem, obwohl, ist, dass bei der Aktualisierung der Benutzeroberfläche aus einem block hatte ich fälschlicherweise verwendet dispatch_sync eher als dispatch_async um die Wichtigsten Warteschlange für die Aktualisierung der Benutzeroberfläche. Einfach mit code-Vervollständigung, und vielleicht schwer zu bemerken, nach der Tat.

    So, für andere das Lesen dieser Frage: wenn die synchrone Ausführung nicht erforderlicheinfach mit dispatch_**a**sync vermeiden die Sackgasse, die Sie möglicherweise zeitweise schlagen.

    InformationsquelleAutor der Antwort pkamb

Schreibe einen Kommentar