Welchen Vorteil(E) hat dispatch_sync haben über @synchronisiert?

Wow. OK-Meine ursprüngliche Bewertung der Leistung war flach aus falsch. Farbe mich dumm.

Nicht so dumm. Mein performance-test falsch war. Behoben. Zusammen mit einem "deep dive" in den GCD-code.

Update: Code für die benchmark finden Sie hier: https://github.com/bbum/StackOverflow Hoffentlich ist es jetzt korrekt. 🙂

Update2: es wurde ein 10-queue-version, die von jeder Art von test.

OK. Umschreiben die Antwort:

• @synchronized() gewesen herum für eine lange Zeit. Es ist implementiert als hash-lookup zu finden, eine Sperre, die ist dann gesperrt. Es ist "ziemlich schnell" - in der Regel schnell genug-aber auch eine Last sein kann, die unter hohem Streit (wie jede Synchronisations-primitive).

• dispatch_sync() nicht unbedingt ein Schloss, noch ist es erforderlich den block kopiert werden. Insbesondere in der fastpath Fall, die dispatch_sync() wird, rufen Sie den block direkt auf dem aufrufenden thread, ohne Sie zu kopieren den block. Auch in der slowpath Fall, wird der Baustein nicht kopiert werden, da der aufrufende thread blockiert, bis die Ausführung sowieso (der aufrufende thread angehalten, bis alles, was Arbeit ist vor der dispatch_sync() fertig ist, dann wird der Faden wieder aufgenommen wird). Die einzige Ausnahme ist der Aufruf auf das Haupt-queue/thread; in diesem Fall wird der block immer noch nicht kopiert (weil der aufrufende thread angehalten und, wenn Sie also einen block aus dem Stapel ist OK), aber es ist ein Haufen Arbeit das einreihen auf der main queue, ausführen und dann wieder dem aufrufenden thread.

• dispatch_async() erforderlich, dass der block kopiert werden, wie es nicht ausführen von auf dem aktuellen thread noch kann der aktuelle thread blockiert (da der block kann sofort sperren auf einige thread-lokale Ressource, die nur auf die Zeile des Codes nach der dispatch_async(). Während teuer, dispatch_async() bewegt sich die Arbeit aus dem aktuellen thread, so dass es zur Wiederaufnahme der Ausführung sofort.

Endergebnis -- dispatch_sync() ist schneller als @synchronized, aber nicht durch einen allgemein sinnvollen Betrag (auf eine '12-iMac, noch '11 mac mini -- #s zwischen den beiden sind sehr unterschiedlich, btw... die Freuden der Parallelität). Mit dispatch_async() ist langsamer als beide in der uncontended Fall, aber nicht viel. Jedoch, die Verwendung von 'dispatch_async()' ist deutlich schneller, wenn die Ressource, die unter Konflikten.

@synchronized uncontended add: 0.14305 seconds
Dispatch sync uncontended add: 0.09004 seconds
Dispatch async uncontended add: 0.32859 seconds
Dispatch async uncontended add completion: 0.40837 seconds
Synchronized, 2 queue: 2.81083 seconds
Dispatch sync, 2 queue: 2.50734 seconds
Dispatch async, 2 queue: 0.20075 seconds
Dispatch async 2 queue add completion: 0.37383 seconds
Synchronized, 10 queue: 3.67834 seconds
Dispatch sync, 10 queue: 3.66290 seconds
Dispatch async, 2 queue: 0.19761 seconds
Dispatch async 10 queue add completion: 0.42905 seconds

Nehmen Sie die oben mit einem Körnchen Salz; es ist ein micro-benchmark der schlimmsten Art, dass es nicht die Darstellung einer wirklichen Welt gemeinsame Nutzung Muster. Die "unit of work" ist wie folgt, und die Ausführungszeiten der oben darstellen von 1.000.000 Ausführungen.

- (void) synchronizedAdd:(NSObject*)anObject
{
    @synchronized(self) {
        [_a addObject:anObject];
        [_a removeLastObject];
        _c++;
    }
}

- (void) dispatchSyncAdd:(NSObject*)anObject
{
    dispatch_sync(_q, ^{
        [_a addObject:anObject];
        [_a removeLastObject];
        _c++;
    });
}

- (void) dispatchASyncAdd:(NSObject*)anObject
{
    dispatch_async(_q, ^{
        [_a addObject:anObject];
        [_a removeLastObject];
        _c++;
    });
}

(_c wird auf 0 zurückgesetzt, am Anfang von jedem Durchgang, und behauptet, um == zu der Anzahl der Testfälle am Ende, um sicherzustellen, dass der code tatsächlich die Ausführung aller arbeiten, bevor spuckt der Zeit.)

Für die uncontended Fall:

start = [NSDate timeIntervalSinceReferenceDate];
_c = 0;
for(int i = 0; i < TESTCASES; i++ ) {
    [self synchronizedAdd:o];
}
end = [NSDate timeIntervalSinceReferenceDate];
assert(_c == TESTCASES);
NSLog(@"@synchronized uncontended add: %2.5f seconds", end - start);

Für die Behauptung aufgestellt, 2 queue, Fall (q1 und q2 sind Seriell):

    #define TESTCASE_SPLIT_IN_2 (TESTCASES/2)
start = [NSDate timeIntervalSinceReferenceDate];
_c = 0;
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
    dispatch_apply(TESTCASE_SPLIT_IN_2, serial1, ^(size_t i){
        [self synchronizedAdd:o];
    });
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{
    dispatch_apply(TESTCASE_SPLIT_IN_2, serial2, ^(size_t i){
        [self synchronizedAdd:o];
    });
});
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
end = [NSDate timeIntervalSinceReferenceDate];
assert(_c == TESTCASES);
NSLog(@"Synchronized, 2 queue: %2.5f seconds", end - start);

Oben werden einfach wiederholt, für jede work unit Variante (keine tricksy runtime-y-magic im Einsatz; copypasta FTW!!!).

In diesem Sinne:

• Verwenden Sie @synchronized() wenn Sie mögen, wie es aussieht. Die Realität ist, dass, wenn Ihr code wird behauptet, auf dem array, ist wahrscheinlich ein Architektur-Problem. Hinweis: mit @synchronized(someObject) kann unbeabsichtigte Folgen haben, dass es kann dazu führen, weitere Konflikte, wenn das Objekt intern verwendet @synchronized(self)!

• Verwenden Sie dispatch_sync() mit einer seriellen queue, wenn das ist Ihre Sache. Es gibt keine overhead-es ist eigentlich schneller, sowohl in der Schalt-und uncontended Fall ist -- und mit queues sind leichter zu Debuggen und einfacher zu Profil, der Instrumente und der Debugger haben beide ausgezeichnete tools für debugging-Warteschlangen (und Sie sind immer besser die ganze Zeit) in der Erwägung, dass die debugging-sperren können ein Schmerz sein.

• Verwenden Sie dispatch_async() mit unveränderlichen Daten für die stark umkämpften Ressourcen. I. e.:

- (void) addThing:(NSString*)thing { 
    thing = [thing copy];
    dispatch_async(_myQueue, ^{
        [_myArray addObject:thing];
    });    
}

Schließlich sollte es eigentlich egal, welche Sie verwenden, für die Aufrechterhaltung, den Inhalt einer array. Die Kosten des Streites hat, ist außerordentlich hoch für den synchronen Fall. Für den asynchronen Fall werden die Kosten von Konflikten geht den Weg nach unten, aber das potential für Komplexität ist komisch oder performance-Fragen geht Weg.

Beim entwerfen Auger Systeme ist es am besten, um die Grenze zwischen Warteschlangen so gering wie möglich. Ein großer Teil davon ist, sicherzustellen, dass so wenig Ressourcen wie möglich "live" auf beiden Seiten der Grenze.

Ok,
Ich habe getan, einige weitere tests, und hier sind die Ergebnisse:

lock-test: mean:2.48661, stdDev:0.50599

synchronisiert-test: mean:2.51298, stdDev:0.49814

Versand Test: mean:2.17046, stdDev:0.43199

So, ich war falsch, mein Fehler 🙁
Wenn jemand interessiert ist, in der test-code ist es Erfolg hier:

static NSInteger retCount = 0;

@interface testObj : NSObject
@end

@implementation testObj

-(id)retain{
    retCount++;
    return [super retain];
}
@end

@interface ViewController : UIViewController{
    NSMutableArray* _a;
    NSInteger _c;
    NSLock* lock;
    NSLock* thlock;
    dispatch_queue_t _q;
}

- (IBAction)testBtn:(id)sender;
@end

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];
}

-(NSTimeInterval)testCase:(SEL)aSel name:(NSString*)name{
    _a = [[NSMutableArray alloc] init];
    retCount = 0;
    //Sync test
    NSThread* th[10];
    for(int t = 0; t < 10;t ++){
        th[t] = [[NSThread alloc] initWithTarget:self selector:aSel object:nil];
    }

    NSTimeInterval start = [NSDate timeIntervalSinceReferenceDate];
    for(int t = 0; t < 10;t ++){
        [th[t] start];
    }
    NSInteger thCount = 1;
    while(thCount > 0){
        thCount = 0;
        for(int t = 0; t < 10;t ++){
            thCount += [th[t] isFinished] ? 0 : 1;
        }
    }
    NSTimeInterval end = [NSDate timeIntervalSinceReferenceDate];
    NSLog(@"%@: %2.5f, retainCount:%d, _c:%d, objects:%d", name, end-start, retCount, _c, [_a count]);
    [_a release];
    for(int t = 0; t < 10;t ++){
        [th[t] release];
    }
    return end-start;
}

-(void)syncTest{
    for(int t = 0; t < 5000; t ++){
        [self synchronizedAdd:[[[testObj alloc] init] autorelease] ];
    }
}

-(void)dispTest{
    for(int t = 0; t < 5000; t ++){
        [self dispatchSyncAdd:[[[testObj alloc] init] autorelease] ];
    }
}

-(void)lockTest{
    for(int t = 0; t < 5000; t ++){
        [self lockAdd:[[[testObj alloc] init] autorelease] ];
    }
}


- (void) synchronizedAdd:(NSObject*)anObject
{
    @synchronized(self) {
        [_a addObject:anObject];
        _c++;
    }
}

- (void) dispatchSyncAdd:(NSObject*)anObject
{
    dispatch_sync(_q, ^{
        [_a addObject:anObject];
        _c++;
    });
}

- (void) lockAdd:(NSObject*)anObject
{
    [lock lock];
        [_a addObject:anObject];
        _c++;
    [lock unlock];
}

- (double)meanOf:(NSArray *)array
{
    double runningTotal = 0.0;

    for(NSNumber *number in array)
    {
        runningTotal += [number doubleValue];
    }

    return (runningTotal / [array count]);
}

- (double)standardDeviationOf:(NSArray *)array
{
    if(![array count]) return 0;

    double mean = [self meanOf:array];
    double sumOfSquaredDifferences = 0.0;

    for(NSNumber *number in array)
    {
        double valueOfNumber = [number doubleValue];
        double difference = valueOfNumber - mean;
        sumOfSquaredDifferences += difference * difference;
    }

    return sqrt(sumOfSquaredDifferences / [array count]);
}

-(void)stats:(NSArray*)data name:(NSString*)name{
    NSLog(@"%@: mean:%2.5f, stdDev:%2.5f", name, [self meanOf:data], [self standardDeviationOf:data]);
}

- (IBAction)testBtn:(id)sender {
    _q = dispatch_queue_create("array q", DISPATCH_QUEUE_SERIAL);
    lock = [[NSLock alloc] init];
    NSMutableArray* ltd = [NSMutableArray array];
    NSMutableArray* std = [NSMutableArray array];
    NSMutableArray* dtd = [NSMutableArray array];
    for(int t = 0; t < 20; t++){
        [ltd addObject: @( [self testCase:@selector(lockTest) name:@"lock Test"] )];
        [std addObject: @( [self testCase:@selector(syncTest) name:@"synchronized Test"] )];
        [dtd addObject: @( [self testCase:@selector(dispTest) name:@"dispatch Test"] )];
    }
    [self stats: ltd name:@"lock test"];
    [self stats: std name:@"synchronized test"];
    [self stats: dtd name:@"dispatch Test"];
}
@end