GCD的奥秘

很多编程语言都会有多线程编程，抛开多线程编程的复杂性，它确实能够提升程序执行的效率
。特别是现在CPU都是多核，能够充分发挥多核的优势也是一些编程语言的追求，比如说golang，
熟悉Golang或者java的开发者，应该都对多线程很熟悉，然而在objc中，使用GCD来进行多线
程的编码要来得更优雅、更简单，下来就来揭开其神秘面纱。

API

开发者要做的只是将想执行的任务追加到适当的Dispatch Queue中去。

dispatch_async(queue, ^{
    /*
     *想执行的任务
     */
})

上面的代码是使用GCD的一般格式，其中的queue分为两种：

1. Serial Dispatch Queue (串行队列)
2. Concurrent Dispatch Queue (并行队列)

很好理解，串行队列中的任务会在一个线程中串行执行，并行队列中的任务会在多个线程中
并行执行。那么如何得到这两个队列呢？

1. dispatch_queue_create

    dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.gcd.serialDispatchQueue", Operation)
    
上述Operation指示生成队列的类型，NULL和DISPATCH_QUEUE_SERIAL为串行，DISPATCH_QUEUE_CONCURRENT
为并行。

2. 获取系统提供的队列
_queue = dispatch_get_main_queue();
_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);

第一个为主线程队列，是串行的，后四个为全局并行队列，可以通过参数来区分其优先级

上面总结了GCD的最基本的用法，当然还有很多很实用的API，如下：

1. dispatch_set_target_queue
可以变更Queue的优先级，还可以将多个queue中的任务归并到某一个queue中。

2. dispatch_after
可以延迟某个任务的执行，但是要注意：这里的延迟并不是任务在指定时间之后执行，而是
延迟指定时间追加到队列中去。

3. dispatch_group_async
如果想要追加到queue中的多个处理结束后进行结束处理，是使用dispatch_group的绝佳场景。
当然将这些任务依次放入一个串行队列中就可以解决问题，但是使用并行队列时，就需要
使用dispatch group了。

4. dispatch_barrier_asyc
dispatch_barrier允许在一个并发队列中创建一个同步点，当在并发队列中遇到一个barrier，
它会等到在这个barrier之前提交的所有任务都执行完毕之后，再执行，而所有在barrier之
后提交的任务会等到barrier之后再执行。

5. dispatch_semaphore
是GCD的同步信号量，

上面所说的都是异步GCD的API，当然还有一些同步的API可以使用，也很重要。

1. dispatch_apply
该函数按指定的次数将指定的block加入到指定的queue中去，并等待全部处理执行结束。
由于此API是同步的，所以一般在dispatch_async中使用它比较常见。

2. dispatch_once
函数保证在应用程序中只执行一次任务，普遍应用于单例对象的初始化。

3. dispatch_semaphore
GCD中的同步信号量，能够比dispatch_group等提供更细粒度的同步控制，使用很广泛。

GCD使用案例

如果多个线程同时操作（读写）一个可变容器，就很有可能会出现线程安全的问题，当一个线程
正在读取时另一个线程正在修改就是一个不安全的行为，例如：

    - (void)addObject:(NSObject *)obj {
        if (obj) {
            [mutableArray addObject: obj];
            dispatch_async(dispatch_get_main_queue(), ^{
                [self postContentAddedNotification];
            });
        }
    }
    
    - (NSArray *)objects {
        return [NSArray arrayWithArray:mutableArray];
    }

如果使用GCD来改写这段不太安全的代码，效果将是这样的。

    - (void)addObject:(NSObject *)obj {
        if (obj) {
            dispatch_barrier_async(self.concurrentQueue, ^{
            [mutableArray addObject:obj];
            dispatch_async(dispatch_get_main_queue(), ^{
                [self postContentAddedNotification]; 
            });
        });
        }
    }
    
    - (NSArray *)objects {
        __block NSArray *array;
        dispatch_sync(self.concurrentQueue, ^{
            array = [NSArray arrayWithArray:_mutableArray];
        });
        return array;
    }

这段代码中，写入数据通过一个barrier来完成，因为barrierBlock永远不会和其它Block一
起执行，所以保证了写安全。在读的时候，使用同步调用，确保了函数返回。在写客户端代
码的时候不会像服务端那样变态地去考虑多线程问题，但是在编码过程中意识到哪些地方可能
会出错还是很重要的。

死锁

GCD相当好用，但用不好就会死锁,始终要记着这样一句秘籍：不要在串行队列放dispatch_sync、
dispatch_apply，比如：

案例一

dispatch_sync(dispatch_get_main_queue(), ^{

        NSLog(@"test");

    });

案例二

//queue为串行队列
dispatch_async(queue, ^{

    dispatch_sync(queue, ^{  
    
        NSLog(@"1"); // 任务1
        
    });
    
NSLog(@"2"); // 任务2

});

上文中两个死锁的例子对于dispatch_apply同样适用。

GCD的奥秘

API

GCD使用案例

死锁

推荐阅读更多精彩内容