iOS开发：深入理解GCD（二）

1.Dispatch Group
  在追加到Dispatch Queue中的多个任务处理完毕之后想执行结束处理，这种需求经常出现。如果只是使用一个Serial Dispatch Queue时，只要将想执行的处理全部追加到该串行队列中并在最后追加结束处理即可。但在使用Concurrent Dispatch Queue时或同时使用多个Dispatch Queue时，源代码会变得颇为复杂。
  这种情况下，可以使用Dispatch Group。

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, dispatchQueue, ^{
        for (int i = 0; i < 100; i++) {
            if (i== 99) {NSLog(@"循环任务99");}
        }
    });
    dispatch_group_async(group, dispatchQueue, ^{NSLog(@"任务2"); });
    dispatch_group_async(group, dispatchQueue, ^{NSLog(@"任务3");});
    dispatch_group_notify(group, dispatchQueue, ^{NSLog(@"任务结束");});

打印结果

  另外，在Dispatch Group中也可以使用dispatch_group_wait函数仅等待全部处理执行结束。dispatch_group_wait函数第二个参数指定为等待时间，源码中使用DISPATCH_TIME_FOREVER意味着永久等待。只要属于DispatchGroup的处理尚未结束，就会一直等待，中途不能取消。

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_async(group, dispatchQueue, ^{
        for (int i = 0; i < 100; i++) {
            if (i== 99) {NSLog(@"循环任务99");}
        }
    });
    dispatch_group_async(group, dispatchQueue, ^{NSLog(@"任务2");});
    dispatch_group_async(group, dispatchQueue, ^{NSLog(@"任务3");});
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    dispatch_group_async(group, dispatchQueue, ^{NSLog(@"任务结束");});

2.dispatch_barrier_async
  在访问数据库或者文件时，可以使用Serial Dispatch Queue可避免数据竞争的问题。
  平常代码中，如果要保证某个属性可以线程安全的读写，通常要使用锁来实现某种同步机制。iOS提供了一种加锁的方式。就是采用内置的synchronization block。

- (void)setName:(NSString *)name
{
    @synchronized(self) {
        _name = [name copy];
    }
}
 
- (NSString *)name
{
    @synchronized(self) {
        return _name;
    }
}

  这种写法会根据给定的对象，自动创建一个锁，并等待块中的代码执行完毕。执行到这段代码结尾处，锁也就释放了，上面的代码中，同步行为所针对的对象是self，这样写通常没错，但@synchronized(self)会大大降低代码效率，因为公用同一个锁的同步块，必须按顺序执行。（上面的写法就是atomic，原子性属性）虽然可以在一定程度上提供“线程安全”，但却无法保证访问该对象时是绝对线程安全。因为在访问属性时，必可以从中得到有效值，而如果再一个线程上多次调用getter方法，每次得到的结果未必相同，在两次操作之间，其他线程可能会写入新的属性值。
  可以使用GCD代替同步块或锁对象，使用串行同步队列，将读操作以及写操作都安排在一个队列中，即可保证数据同步。

dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.test", DISPATCH_QUEUE_SERIAL);

- (void)setName:(NSString *)name
{
    dispatch_sync(_queue, ^{
        _name = [name copy];
    });
}
 
- (NSString *)name
{
    __block NSString *tempName;
    dispatch_sync(_queue, ^{
        tempName = _name;
    });
    return tempName;
}

  这样写的思路是：把写操作与读操作都安排在同一个同步串行队列里执行，这样所有针对属性的访问操作就都同步了。
  但这样的写法只可以实现单读、单写。我们要解决的是在写的过程中不能被读，以免数据不对，但是读与读之间没有冲突。
  多个getter方法可以并发执行，而getter与setter方法是不能并发执行的。

dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.test", DISPATCH_QUEUE_CONCURRENT);

- (void)setName:(NSString *)name
{
      dispatch_barrier_async(_concurrentQueue, ^{
        _name = [name copy];
    });
}
 
- (NSString *)name
{
    __block NSString *tempName;
    dispatch_sync(_queue, ^{
        tempName = _name;
    });
    return tempName;
}

代码中dispatch_barrier_async函数会等待追加到并发队列上的处理全部结束后，再将指定的处理追加到该并发队列上。然后在由dispatch_barrier_async函数追加的处理执行完毕后，该并发队列才恢复一般的动作。

3.dispatch_apply与dispatch_once
dispatch_apply函数按指定的次数将指定的Block追加到指定的Dispatch Queue中，并等待全部处理执行结束。

    dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(10, dispatchQueue, ^(size_t index) {
        NSLog(@"%zu",index);
    });

dispatch_once函数是保证应用程序执行中只执行一次指定处理。保证了多线程环境下安全。

    static dispatch_once_t pred;
    dispatch_onece( &pred, ^{
  //初始化
    });

4.Dispatch Semaphore
Dispatch Semaphore 是持有计数的信号，该计数是多线程编程中的计数类型信号。计数为0时等待，计数为1或大于1时， 减去1而不等待。

    dispatch_queue_t dispatchQueue = dispatch_queue_create("ted.queue.test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
    NSMutableArray *array = [[NSMutableArray alloc] init];
    for(int i = 0; i < 1000; ++i){
        dispatch_async(dispatchQueue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            [array addObject:[NSNumber numberWithInt:i]];
            dispatch_semaphore_signal(semaphore);
        });
    }

在没有串行队列和dispatch_barrier_async函数那么大粒度且一部分处理需要进行排他控制的情况下使用。