Mike Ash Singleton: Platzierung @synchronized

Question

ich quer durch das auf dem Mike Ash „Pflege und Fütterung von Singletons“ kam und war ein wenig von seinem Kommentar puzzeled:

Dieser Code ist etwas langsam, aber. Eine Sperre ist etwas teuer. Making es schmerzhafter ist die Tatsache , dass die überwiegende Mehrheit der Zeit, das Schloss ist sinnlos. Die Sperre wird nur benötigt, wenn foo null ist, was grundsätzlich nur einmal passiert. Nachdem der Singleton initialisiert wurde, ist die Notwendigkeit für das Schloss weg, aber das Schloss selbst bleibt .

+(id)sharedFoo { 
    static Foo *foo = nil; 
    @synchronized([Foo class]) { 
     if(!foo) foo = [[self alloc] init]; 
    } 
    return foo; 
} 

Meine Frage ist, und es besteht kein Zweifel ein guter Grund dafür, aber warum können Sie nicht schreiben (siehe unten), um die Sperre zu begrenzen, wenn foo ist gleich Null?

+(id)sharedFoo { 
    static Foo *foo = nil; 
    if(!foo) { 
     @synchronized([Foo class]) { 
      foo = [[self alloc] init]; 
     } 
    } 
    return foo; 
} 

prost gary

Answer 1

Weil dann der Test zu einer Race-Bedingung unterliegt. Zwei verschiedene Threads könnten unabhängig testen, dass foonil ist, und dann (sequenziell) separate Instanzen erstellen. Dies kann in Ihrer modifizierten Version vorkommen, wenn ein Thread den Test ausführt, während sich die andere noch innerhalb von +[Foo alloc] oder -[Foo init] befindet, aber foo noch nicht festgelegt ist.

Übrigens würde ich es nicht so machen. Sehen Sie sich die Funktion dispatch_once() an, mit der Sie garantieren können, dass ein Block während der Laufzeit Ihrer App nur einmal ausgeführt wird (vorausgesetzt, Sie haben GCD auf der Plattform, auf die Sie ausgerichtet sind).

Answer 2

In Ihrer Version könnte die Überprüfung für !foo gleichzeitig bei mehreren Threads auftreten, sodass zwei Threads in den Block alloc springen können. Einer wartet darauf, dass der andere beendet wird, bevor er eine andere Instanz zuweist.

Answer 3

Sie können optimieren, indem Sie nur die Sperre übernehmen, wenn foo == nil, aber danach müssen Sie erneut (innerhalb der @synchronized) testen, um gegen Wettlaufbedingungen zu schützen.

+ (id)sharedFoo { 
    static Foo *foo = nil; 
    if(!foo) { 
     @synchronized([Foo class]) { 
      if (!foo) // test again, in case 2 threads doing this at once 
       foo = [[self alloc] init]; 
     } 
    } 
    return foo; 
} 

Answer 4

Dies wird double checked locking "optimization" genannt. Wie überall dokumentiert, ist dies nicht sicher. Selbst wenn es nicht durch eine Compiler-Optimierung besiegt wird, wird es die Art und Weise, wie Speicher auf modernen Maschinen arbeitet, besiegen, es sei denn, Sie verwenden eine Art Zaun/Barrieren.

Mike Ash also shows die richtige Lösung mit volatile und OSMemoryBarrier();.

Das Problem ist, dass, wenn ein Thread ausgeführt wird foo = [[self alloc] init]; es keine Garantie dafür gibt, dass, wenn ein anderer Thread sieht foo != 0 alle Speicher von init ausgeführt schreibt auch sichtbar.

Siehe auch DCL and C++ und DCL and java für weitere Details.

Answer 5

Der beste Weg, wenn Sie großer cenral Versand

+ (MySingleton*) instance { 
static dispatch_once_t _singletonPredicate; 
static MySingleton *_singleton = nil; 

dispatch_once(&_singletonPredicate, ^{ 
    _singleton = [[super allocWithZone:nil] init]; 
}); 

return _singleton 
} 
+ (id) allocWithZone:(NSZone *)zone { 
    return [self instance]; 
}