Dado el siguiente fragmento de código:

#import <XCTest/XCTest.h>

@interface DispatchTests : XCTestCase {
    dispatch_queue_t _workQueue;
    dispatch_queue_t _readWriteQueue;
    int _value;
}
-(void)read;
-(void)write;
@end

@implementation DispatchTests

-(void)testDispatch {
    _workQueue = dispatch_queue_create("com.work", DISPATCH_QUEUE_CONCURRENT);
    _readWriteQueue = dispatch_queue_create("com.readwrite", DISPATCH_QUEUE_CONCURRENT);
    _value = 0;
    for(int i = 0; i < 100; i++) {
        dispatch_async(_workQueue, ^{
            if(arc4random() % 4 == 0) {
                [self write];
            } else {
                [self read];
            }
        });
    }
    XCTestExpectation* expectation = [self expectationWithDescription:@"dude"];
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        [expectation fulfill];
    });

    [self waitForExpectationsWithTimeout:6.0 handler:nil];
}

-(void)read {
    dispatch_sync(_readWriteQueue, ^{
        NSLog(@"read:%d", _value);
    });
}

-(void)write {
    dispatch_barrier_sync(_readWriteQueue, ^{
        _value++;
        NSLog(@"write:%d", _value);
    });
}

@end

El propósito de esta prueba es ver si puedo usar undispatch_barrier para administrar un bloqueo de lectura / escritura. En esta prueba, tanto el lector como el escritor son sincrónicos. La prueba parece funcionar bien cuando hago la barrera asincrónica, sin embargo, me gustaría evitar el comportamiento asincrónico porque esta implementación no es trivial.

Estoy tratando de entender por quéwrite El método es un punto muerto. De acuerdo con los documentos de GCD:

Cuando el bloque de barrera llega al frente de una cola privada concurrente, no se ejecuta de inmediato. En cambio, la cola espera hasta que sus bloques actualmente en ejecución terminen de ejecutarse. En ese punto, la cola ejecuta el bloque de barrera por sí misma. Los bloques enviados después del bloque de barrera no se ejecutan hasta que el bloque de barrera se complete.

Estoy confundido por lo que se entiende por "bloques actualmente en ejecución".

Mi interpretación es este escenario donde se envían un montón de lecturas (x), luego una escritura (y), luego más lecturas (z):

(x) se ejecuta(y) espera hasta que (x) haya terminado(y) bloquea (z) la ejecución(x) completa(y) se ejecuta(y) completa(z) se ejecuta(z) completa