Du kannst mit NSThread > currentThread > isMainThread testen. Mit der GC API wüsste ich jetzt gerade auch nicht.

Gruß
Manfred

Ist nach manpage auch der empfohlene Weg:

The result of dispatch_get_main_queue() may or may not equal the result
of dispatch_get_current_queue() when called on the main thread. Comparing
the two is not a valid way to test whether code is executing on the main
thread. Foundation/AppKit programs should use [NSThread isMainThread].
POSIX programs may use pthread_main_np(3).

Tjaha, ein beliebtes Problem, dass sich nicht wirklich gut mit GCD lösen lässt. Während man beim Main-Thread noch NSThread verwenden kann, wie hier geschrieben, geht das im allgemeinen nicht.

Erst einmal: Die Frage ist falsch gestellt. Du bist in GCD. In GCD gibt es keine Threads. Es gibt Queues. Richtig formuliert wäre das also:

Bestimmte Dinge müssen immer in Queue erledigt werden. (Ganz typische Problemstellung bei GCD.) Wenn man sich allerdings in Queue befindet, geht dispatch_sync( queue, ^{…} ) nicht.

(Genau genommen geht es, dauert nur sehr, sehr lange … ;-))

Bei der Main-Queue klappt das Ganze nur zufällig deshalb, weil diese Queue mit einem Thread assoziiert ist. Das könnte man jetzt natürlich immer machen. Dann stellt sich jedoch die Frage, wieso man noch GCD verwendet. Ich weiß es nicht.

Es gibt den einfachen Weg, sich zu einer Queue zu merken, in welchem Thread sie gerade ist und das dann zu checken, ob man sich in demselben Thread befindet. Dann einfach den Block ausführen anstatt dispatch_async() zu verwenden. Diese Methode hat jedoch den Nachteil, dass es nicht funktioniert. Erstaunlicherweise wird ein dispatch_sync() nämlich nicht zwingend auf dem Thread ausgeführt, der das dispatch_sync() aufruft. (Man mag das denken, weil der ja jetzt immerhin wartet und daher frei sein muss. Isse aber nicht so und ist auch so dokumentiert. Es heißt nur, dass dispatch_sync() dies versucht. Mir ist nicht ganz klar, was daran hindert. Mutmaßlich kann einer dazwischen kommen und den Thread ganz, ganz schnell klauen. Nun, ja, in Hauptbahnhöfen treiben sich ja gerne flinke Finger herum.

Irgendwer hat daher eine generelle Lösung für das Problem implementiert und irgendwo auf github, google oder sonstwohin gestellt. Die ist sehr tricky, aber von einem Apple-Mitarbeiter reviewed. Genauere Angaben müsste es in meinem Talk zu Nebenläufigkeit bei der Macoun geben. Mutmaßlich lässt sich das aber schneller googlen.

Was ist also der richtige Weg? Aufpassen beim Programmieren. In eine solche Situation gerät man dann, wenn man wild wechselseitig Code aufruft, der mal dispatch_sync() macht, weil er sich "oberhalb" der Synchronisationsschicht befindet und mal nicht dispatch_sync() macht, weil er sich bereits unterhalb der Synchronisationsschicht befindet.

Synchronisationsschicht? Genau das ist das Problem. Man sollte eine genau definierte API haben, die dispatch_sync() benutzt. Alles darüber benutzt *nur* diese API oder alles in sich, niemals aber dispatch_sync().

Ales in der Synchronisationsschicht benutzt *nur* Dinge, die darunter liegen, niemals aber Dinge aus sich selbst oder darüber.

Alles darunter benutzt nur Dinge aus der eigenen Schicht.

Dann schießt man sich nicht so schnell ins Knie. (Oder Fuß, ich glaube, dass mit dem Knie waren Löcher.)

High-Level-API: -> High-Level-API, Sync-API
Sync-API: -> Low-Level-API
Low-Level-API: -> Low-Level-API