1. + (UIColor *)boringColor; 
2. { 
3.     static UIColor *color; 
4.     static dispatch_once_t onceToken; 
5.     dispatch_once(&onceToken, ^{ 
6.         color = [UIColor colorWithRed:0.380f green:0.376f blue:0.376f alpha:1.000f]; 
7.     }); 
8.     return color; 
9. } 

1. - (void)foo 
2. { 
3.     double delayInSeconds = 2.0; 
4.     dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t) (delayInSeconds * NSEC_PER_SEC)); 
5.     dispatch_after(popTime, dispatch_get_main_queue(), ^(void){ 
6.         [self bar]; 
7.     }); 
8. } 

1. - (id)init; 
2. { 
3.     self = [super init]; 
4.     if (self != nil) { 
5.         NSString *label = [NSString stringWithFormat:@"%@.isolation.%p", [self class], self]; 
6.         self.isolationQueue = dispatch_queue_create([label UTF8String], 0); 
7.          
8.         label = [NSString stringWithFormat:@"%@.work.%p", [self class], self]; 
9.         self.workQueue = dispatch_queue_create([label UTF8String], 0); 
10.     } 
11.     return self; 
12. } 

1. - (void)setCount:(NSUInteger)count forKey:(NSString *)key 
2. { 
3.     key = [key copy]; 
4.     dispatch_async(self.isolationQueue, ^(){ 
5.         if (count == 0) { 
6.             [self.counts removeObjectForKey:key]; 
7.         } else { 
8.             self.counts[key] = @(count); 
9.         } 
10.     }); 
11. } 
12.  
13. - (NSUInteger)countForKey:(NSString *)key; 
14. { 
15.     __block NSUInteger count; 
16.     dispatch_sync(self.isolationQueue, ^(){ 
17.         NSNumber *n = self.counts[key]; 
18.         count = [n unsignedIntegerValue]; 
19.     }); 
20.     return count; 
21. } 

1. self.isolationQueue = dispatch_queue_create([label UTF8String], DISPATCH_QUEUE_CONCURRENT); 

1. - (void)setCount:(NSUInteger)count forKey:(NSString *)key 
2. { 
3.     key = [key copy]; 
4.     dispatch_barrier_async(self.isolationQueue, ^(){ 
5.         if (count == 0) { 
6.             [self.counts removeObjectForKey:key]; 
7.         } else { 
8.             self.counts[key] = @(count); 
9.         } 
10.     }); 
11. } 

1. dispatch_queue_t queueA; // assume we have this 
2. dispatch_sync(queueA, ^(){ 
3.     dispatch_sync(queueA, ^(){ 
4.         foo(); 
5.     }); 
6. }); 

1. dispatch_queue_t queueA; // assume we have this 
2. dispatch_queue_t queueB; // assume we have this 
3.  
4. dispatch_sync(queueA, ^(){ 
5.     foo(); 
6. }); 
7.  
8. void foo(void) 
9. { 
10.     dispatch_sync(queueB, ^(){ 
11.         bar(); 
12.     }); 
13. } 
14.  
15. void bar(void) 
16. { 
17.     dispatch_sync(queueA, ^(){ 
18.         baz(); 
19.     }); 
20. } 

1. dispatch_queue_t queueA; // assume we have this 
2. dispatch_async(queueA, ^(){ 
3.     dispatch_async(queueA, ^(){ 
4.         foo(); 
5.     }); 
6. }); 

1. - (void)processImage:(UIImage *)image completionHandler:(void(^)(BOOL success))handler; 
2. { 
3.     dispatch_async(self.isolationQueue, ^(void){ 
4.         // do actual processing here 
5.         dispatch_async(self.resultQueue, ^(void){ 
6.             handler(YES); 
7.         }); 
8.     }); 
9. } 

1. for (size_t y = 0; y < height; ++y) { 
2.     for (size_t x = 0; x < width; ++x) { 
3.         // Do something with x and y here 
4.     } 
5. } 

1. dispatch_apply(height, dispatch_get_global_queue(0, 0), ^(size_t y) { 
2.     for (size_t x = 0; x < width; x += 2) { 
3.         // Do something with x and y here 
4.     } 
5. }); 

1. dispatch_group_t group = dispatch_group_create(); 
2.  
3. dispatch_queue_t queue = dispatch_get_global_queue(0, 0); 
4. dispatch_group_async(group, queue, ^(){ 
5.     // Do something that takes a while 
6.     [self doSomeFoo]; 
7.     dispatch_group_async(group, dispatch_get_main_queue(), ^(){ 
8.         self.foo = 42; 
9.     }); 
10. }); 
11. dispatch_group_async(group, ^(){ 
12.     // Do something else that takes a while 
13.     [self doSomeBar]; 
14.     dispatch_group_async(group, dispatch_get_main_queue(), ^(){ 
15.         self.bar = 1; 
16.     }); 
17. }); 
18.  
19. // This block will run once everything above is done: 
20. dispatch_group_notify(group, dispatch_get_main_queue(), ^(){ 
21.     NSLog(@"foo: %d", self.foo); 
22.     NSLog(@"bar: %d", self.bar); 
23. }); 

1. - (void)withGroup:(dispatch_group_t)group performBlock:(dispatch_block_t)block 
2. { 
3.     if (group == NULL) { 
4.         [self performBlock:block]; 
5.     } else { 
6.         dispatch_group_enter(group); 
7.         [self performBlock:^(){ 
8.             block(); 
9.             dispatch_group_leave(group); 
10.         }]; 
11.     } 
12. } 

1. + (void)withGroup:(dispatch_group_t)group  
2.         sendAsynchronousRequest:(NSURLRequest *)request  
3.         queue:(NSOperationQueue *)queue  
4.         completionHandler:(void (^)(NSURLResponse*, NSData*, NSError*))handler 
5. { 
6.     if (group == NULL) { 
7.         [self sendAsynchronousRequest:request  
8.                                 queue:queue  
9.                     completionHandler:handler]; 
10.     } else { 
11.         dispatch_group_enter(group); 
12.         [self sendAsynchronousRequest:request  
13.                                 queue:queue  
14.                     completionHandler:^(NSURLResponse *response, NSData *data, NSError *error){ 
15.             handler(response, data, error); 
16.             dispatch_group_leave(group); 
17.         }]; 
18.     } 
19. } 

1. NSRunningApplication *mail = [NSRunningApplication  
2.   runningApplicationsWithBundleIdentifier:@"com.apple.mail"]; 
3. if (mail == nil) { 
4.     return; 
5. } 
6. pid_t const pid = mail.processIdentifier; 
7. self.source = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC, pid,  
8.   DISPATCH_PROC_EXIT, DISPATCH_TARGET_QUEUE_DEFAULT); 
9. dispatch_source_set_event_handler(self.source, ^(){ 
10.     NSLog(@"Mail quit."); 
11. }); 
12. dispatch_resume(self.source); 

1. NSURL *directoryURL; // assume this is set to a directory 
2. int const fd = open([[directoryURL path] fileSystemRepresentation], O_EVTONLY); 
3. if (fd < 0) { 
4.     char buffer[80]; 
5.     strerror_r(errno, buffer, sizeof(buffer)); 
6.     NSLog(@"Unable to open \"%@\": %s (%d)", [directoryURL path], buffer, errno); 
7.     return; 
8. } 
9. dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_VNODE, fd,  
10.   DISPATCH_VNODE_WRITE | DISPATCH_VNODE_DELETE, DISPATCH_TARGET_QUEUE_DEFAULT); 
11. dispatch_source_set_event_handler(source, ^(){ 
12.     unsigned long const data = dispatch_source_get_data(source); 
13.     if (data & DISPATCH_VNODE_WRITE) { 
14.         NSLog(@"The directory changed."); 
15.     } 
16.     if (data & DISPATCH_VNODE_DELETE) { 
17.         NSLog(@"The directory has been deleted."); 
18.     } 
19. }); 
20. dispatch_source_set_cancel_handler(source, ^(){ 
21.     close(fd); 
22. }); 
23. self.source = source; 
24. dispatch_resume(self.source); 

1. dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER,  
2.   0, 0, DISPATCH_TARGET_QUEUE_DEFAULT); 
3. dispatch_source_set_event_handler(source, ^(){ 
4.     NSLog(@"Time flies."); 
5. }); 
6. dispatch_time_t start 
7. dispatch_source_set_timer(source, DISPATCH_TIME_NOW, 5ull * NSEC_PER_SEC,  
8.   100ull * NSEC_PER_MSEC); 
9. self.source = source; 
10. dispatch_resume(self.source); 

0: HTTP/1.1 200 OK\r\nDate: Mon, 23 May 2005 22:381: :34 GMT\r\nServer: Apache/1.3.3.7 (Unix) (Red-H2: at/Linux)\r\nLast-Modified: Wed, 08 Jan 2003 233: :11:55 GMT\r\nEtag: "3f80f-1b6-3e1cb03b"\r\nCon4: tent-Type: text/html; charset=UTF-8\r\nContent-5: Length: 131\r\nConnection: close\r\n\r\n<html>\r6: \n<head>\r\n  <title>An Example Page</title>\r\n7: </head>\r\n<body>\r\n  Hello World, this is a ve

dispatch_data_t a; // Assume this hold some valid datadispatch_data_t b; // Assume this hold some valid datadispatch_data_t c = dispatch_data_create_concat(a, b);

dispatch_data_apply(c, ^(dispatch_data_t region, size_t offset, const void *buffer, size_t size) {    fprintf(stderr, "region with offset %zu, size %zu\n", offset, size);    return true;});

dispatch_io_t dispatch_io_create(dispatch_io_type_t type, dispatch_fd_t fd,   dispatch_queue_t queue, void (^cleanup_handler)(int error));

_isolation = dispatch_queue_create([[self description] UTF8String], 0);_nativeSocket = socket(PF_INET6, SOCK_STREAM, IPPROTO_TCP);struct sockaddr_in sin = {};sin.sin_len = sizeof(sin);sin.sin_family = AF_INET6;sin.sin_port = htons(port);sin.sin_addr.s_addr= INADDR_ANY;int err = bind(result.nativeSocket, (struct sockaddr *) &sin, sizeof(sin));NSCAssert(0 <= err, @""); _eventSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, _nativeSocket, 0, _isolation);dispatch_source_set_event_handler(result.eventSource, ^{    acceptConnection(_nativeSocket);});

typedef union socketAddress {    struct sockaddr sa;    struct sockaddr_in sin;    struct sockaddr_in6 sin6;} socketAddressUnion; socketAddressUnion rsa; // remote socket addresssocklen_t len = sizeof(rsa);int native = accept(nativeSocket, &rsa.sa, &len);if (native == -1) {    // Error. Ignore.    return nil;} _remoteAddress = rsa;_isolation = dispatch_queue_create([[self description] UTF8String], 0);_channel = dispatch_io_create(DISPATCH_IO_STREAM, native, _isolation, ^(int error) {    NSLog(@"An error occured while listening on socket: %d", error);}); //dispatch_io_set_high_water(_channel, 8 * 1024);dispatch_io_set_low_water(_channel, 1);dispatch_io_set_interval(_channel, NSEC_PER_MSEC * 10, DISPATCH_IO_STRICT_INTERVAL); socketAddressUnion lsa; // remote socket addresssocklen_t len = sizeof(rsa);getsockname(native, &lsa.sa, &len);_localAddress = lsa;

如果我们想要设置SO_KEEPALIVE（如果我们使用了HTTP的keep-alive等级），我们需要在调用dispatch_io_create前这么做。 创建好I/O通道后，我们可以设置读取处理程序：

dispatch_io_read(_channel, 0, SIZE_MAX, _isolation, ^(bool done, dispatch_data_t data, int error){    if (data != NULL) {        if (_data =http://www.mamicode.com/= NULL) {>
如果所有你想做的只是读取或者写入一个文件，GCD提供了两个方便的包装器：dispatch_read和dispatch_write。你需要传递给dispatch_read一个文件路径和一个在所有数据块读取完后调用的代码块。类似的，dispatch_write需要一个文件路径和一个被写入的dispatch_data_t对象。
 
9、基准测试
在GCD的一个不起眼的角落，你会发现一个适合优化代码的灵巧小工具：
uint64_t dispatch_benchmark(size_t count, void (^block)(void));
把这个声明放到你的代码中，你就能够测量给定的代码块执行的平均的纳秒数。例子如下：
size_t const objectCount = 1000;uint64_t n = dispatch_benchmark(10000, ^{    @autoreleasepool {        id obj = @42;        NSMutableArray *array = [NSMutableArray array];        for (size_t i = 0; i < objectCount; ++i) {            [array addObject:obj];        }    }});NSLog(@"-[NSMutableArray addObject:] : %llu ns", n);
在我的机器上输出了：
-[NSMutableArray addObject:] : 31803 ns 
也就是说添加1000个对象到NSMutableArray总共消耗了31803纳秒，或者说平均一个对象消耗32纳秒。
 
正如dispatch_benchmark的帮助界面指出的，测量性能并非如看起来那样不重要。尤其是当比较并发代码和非并发代码时，你需要注意你的硬件上运行的特定计算带宽和内存带宽。不同的机器会很不一样。如果代码的性能与访问临界区有关，那么我们上面提到的锁竞争问题就会有所影响。
 
不要把它放到发布代码中，事实上，这是无意义的，它是私有API。它只是在调试和性能分析上起作用。
访问帮助界面：
curl "http://opensource.apple.com/source/libdispatch/libdispatch-84.5/man/dispatch_benchmark.3?txt"   | /usr/bin/groffer --tty -T utf8 
10、原子操作
头文件libkern/OSAtomic.h里有许多强大的函数，专门用来底层多线程编程。尽管它是内核头文件的一部分，它也能够在内核之外来帮助编程。
 
这些函数都是很底层的，并且你需要知道一些额外的事情。就算你已经知道了，你还可能会发现一两件你不能做，或者不易做的事情。当你正在为高性能代码工作或者正在实现无锁的和无等待的算法工作时，这些函数会变得很有趣。
 
这些函数在atomic(3)的帮助页里全部有概述——运行man 3 atomic命令以得到完整的文档。你会发现里面讨论到了内存屏障。查看维基百科中关于内存屏障的文章。如果你不能确定，那么你很可能需要它。
 
10.1、计数器
OSAtomicIncrement和OSAtomicDecrement有一个很长的函数列表允许你以原子操作的方式去增加和减少一个整数值，这不必使用锁（或者队列）同时也是线程安全的。如果你需要让一个全局的计数器值增加，而这个计数器为了统计目的而由多个线程操作，使用原子操作是很有帮助的。如果你要做的仅仅是增加一个全局计数器，那么无屏障版本的OSAtomicIncrement是很合适的，并且当没有锁竞争时，调用它们的代价很小。
 
类似的，OSAtomicOr，OSAtomicAnd，OSAtomicXor的函数能用来进行逻辑运算，而OSAtomicTest可以用来设置和清除位。
 
10.2、比较和交换
OSAtomicCompareAndSwap能用来做无锁的懒初始化，如下：
void * sharedBuffer(void){    static void * buffer;    if (buffer == NULL) {        void * newBuffer = calloc(1, 1024);        if (!OSAtomicCompareAndSwapPtrBarrier(NULL, newBuffer, &buffer)) {            free(newBuffer);        }    }    return buffer;}
如果没有缓冲区，我们会创建一个然后自动将其写到buffer中如果buffer为NULL。在极稀少的情况下，其他人因为多线程也同时设置了buffer，我们简单的将其释放掉。因为比较和交换方法是原子的，所以它是一个线程安全的方式去懒初始化值。NULL的检测和设置buffer是以原子方式完成的。
 
明显的，使用dispatch_once()我们也可以完成类似的事情。
 
10.3、原子队列
OSAtomicEnqueue()和OSAtomicDequeue()可以让你实现一个LIFO队列，以线程安全，无锁的方式。对有潜在精确要求的代码来说，这会是强大的构建方式。
 
还有OSAtomicFifoEnqueue()和OSAtomicFifoDequeue()是为了操作FIFO队列，但这些只有在头文件中才有文档——使用他们的时候要小心。
 
10.4、自旋锁
最后，OSAtomic.h头文件定义了使用自旋锁的函数：OSSpinLock。再次的，维基百科有深入的有关自旋锁的信息。使用命令man 3 spinlock查看帮助页的spinlock(3)。当没有锁竞争时使用自旋锁代价很小。
 
在合适的情况下，使用自旋锁对性能优化是很有帮助的。一如既往：先测量，然后优化。不要做乐观的优化。
 
下面是OSSpinLock的一个例子：
@interface MyTableViewCell : UITableViewCell @property (readonly, nonatomic, copy) NSDictionary *amountAttributes; @end   @implementation MyTableViewCell{    NSDictionary *_amountAttributes;} - (NSDictionary *)amountAttributes;{    if (_amountAttributes == nil) {        static __weak NSDictionary *cachedAttributes = nil;        static OSSpinLock lock = OS_SPINLOCK_INIT;        OSSpinLockLock(&lock);        _amountAttributes = cachedAttributes;        if (_amountAttributes == nil) {            NSMutableDictionary *attributes = [[self subtitleAttributes] mutableCopy];            attributes[NSFontAttributeName] = [UIFont fontWithName:@"ComicSans" size:36];            attributes[NSParagraphStyleAttributeName] = [NSParagraphStyle defaultParagraphStyle];            _amountAttributes = [attributes copy];            cachedAttributes = _amountAttributes;        }        OSSpinLockUnlock(&lock);    }    return _amountAttributes;}
在上面的例子中，或许用不着这么麻烦，但它演示了一种理念。我们使用了ARC的__weak来确保一旦MyTableViewCell所有的实例都不存在，amountAttributes会调用dealloc。因此在所有的实例中，我们可以持有字典的一个单独实例。
 
这段代码运行良好的原因是我们不太可能访问到函数内部的部分。这是很深奥的——不要在你的App中使用它，除非是你真正需要。
底层并发APIs_源自objc.io