GCD

dispatch_async(queue, blk0); 
dispatch_async(queue, blk1); 
dispatch_async(queue, blk2); 
dispatch_async(queue, blk3); 
dispatch_async(queue, blk4); 
dispatch_async(queue, blk5); 

// Serial Dispatch Queue
dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);
// Concurrent Dispatch Queue
dispatch_queue_t myConcurrentDispatchQueue = dispatch_queue_create("com.example.gcd.MyConcurrentDispatchQueue", DISPATCH_QUEUE_CONCURRENT);

dispatch_async(myConcurrentDispatchQueue, ^{NSLog(@"block on myConcurrentDispatchQueue");});

// Main Dispatch Queue
dispatch_queue_t mainDispatchQueue = dispatch_get_main_queue();
// Global Dispatch Queue
dispatch_queue_t globalDispatchQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// Execute a Block on a global dispatch queue of default priority.
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

    // 这里可以写一些并发执行的任务.
    // ...
    
    // Then, execute a Block on the main dispatch queue.
    dispatch_async(dispatch_get_main_queue(), ^{
        // 这里可以写只能在主线程执行的任务，比如更新界面等。
        // ...
    });
    
});

dispatch_queue_t mySerialDispatchQueue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);
dispatch_queue_t globalDispatchQueueBackground = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(mySerialDispatchQueue, globalDispatchQueueBackground);

dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull * NSEC_PER_SEC); 
dispatch_after(time, dispatch_get_main_queue(), ^{
	NSLog(@"waited at least three seconds.");
});

// 获得系统提供的 Global Dispatch Queue。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 创建 Dispatch Group，注意跟 dispatch_queue_create 一样，在 MRC 环境下或者 iOS 6 之前的版本 ARC 环境下需要用 dispatch_release(group)。
dispatch_group_t group = dispatch_group_create();

// 添加任务 Block 到任务队列 queue 中。
dispatch_group_async(group, queue, ^{NSLog(@"blk0");});
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});

// 通知 group，那几个任务都结束了。
dispatch_group_notify(group, dispatch_get_main_queue(), ^{NSLog(@"done");});

blk1
blk2
blk0
done

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();

dispatch_group_async(group, queue, ^{NSLog(@"blk0");});
dispatch_group_async(group, queue, ^{NSLog(@"blk1");});
dispatch_group_async(group, queue, ^{NSLog(@"blk2");});    

// 等待一秒钟。可以指定 DISPATCH_TIME_FOREVER 来永久等待；可以指定 DISPATCH_TIME_NOW 立即判断。
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull * NSEC_PER_SEC);
long result = dispatch_group_wait(group, time);
if (result == 0) {
    // 所有与 group 关联的任务都已经执行完成了。
} else {
    // 与 group 关联的任务只有部分执行完了，还有没执行完的。
}

dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.ForBarrier", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, blk0_for_reading);
dispatch_async(queue, blk1_for_reading);
dispatch_async(queue, blk2_for_reading);
dispatch_async(queue, blk3_for_reading);
dispatch_barrier_async(queue, blk_for_writing);
dispatch_async(queue, blk4_for_reading);
dispatch_async(queue, blk5_for_reading);
dispatch_async(queue, blk6_for_reading);
dispatch_async(queue, blk7_for_reading);

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(queue, ^{/* a task */});

// 死锁示例 1：我停掉当前线程，去等主线程完成后，再执行 Block。额，当前线程就是主线程，它被停掉了，怎么完成执行啊。
dispatch_queue_t queue = dispatch_get_main_queue(); 
dispatch_sync(queue, ^{NSLog(@"Hello?");});

// 死锁示例 2：
dispatch_queue_t queue = dispatch_get_main_queue(); 
dispatch_async(queue, ^{
    dispatch_sync(queue, ^{NSLog(@"Hello?");}); 
});

// 死锁示例 3：
dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.MySerialDispatchQueue", NULL);
dispatch_async(queue, ^{
    dispatch_sync(queue, ^{NSLog(@"Hello?");});
});

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(5, queue, ^(size_t index) {
    NSLog(@"%zu", index);
}); 
NSLog(@"done");

4
3
1
0
2
done

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    // 在 Global Dispatch Queue 中异步执行的任务。
    dispatch_async(queue, ^{
        // 在 Global Dispatch Queue 中会等待 dispatch_apply 函数中的全部任务都结束才继续。
        dispatch_apply([array count], queue, ^(size_t index) {
            // 并行处理 array 中的全部对象。
            NSLog(@"%zu: %@", index, [array objectAtIndex:index]);
        });
        
        // dispatch_apply 函数中的任务全部执行结束。
        
        // 在 Main Dispatch Queue 中异步执行的任务。
        dispatch_async(dispatch_get_main_queue(), ^{
            // 执行用户界面刷新等操作。
            NSLog(@"done");
        });
    });

// 挂起指定的 Dispatch Queue。
dispatch_suspend(queue);
// 恢复执行指定的 Dispatch Queue。
dispatch_resume(queue);

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSMutableArray *array = [[NSMutableArray alloc] init];
for (int i = 0; i < 100000; ++i) {
    dispatch_async(queue, ^{
        [array addObject:[NSNumber numberWithInt:i]];
    });
}

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 创建 Dispatch Semaphore，计数初始值为 1，保证可访问 NSMutableArray 对象的线程同时只能有 1 个。
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
NSMutableArray *array = [[NSMutableArray alloc] init];
for (int i = 0; i < 100000; ++i) { 
    dispatch_async(queue, ^{
        // 一直等待，直到 Dispatch Semaphore 的计数值达到大于等于 1。
        // 当 Dispatch Semaphore 的值达到大于等于 1 时dispatch_semaphore_wait 函数将 dispatch_semaphore_wait 的计数值减去 1，函数返回。
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        
        // 这里 Dispatch Semaphore 的计数值恒为 0。
        // 此时访问 NSMutableArray 的线程只有 1 个，可以安全操作。
        [array addObject:[NSNumber numberWithInt:i]];
        
        // 排他控制结束，调用 dispatch_semaphore_signal 将 Dispatch Semaphore 计数值加 1。
        // 这时如果有在 dispatch_semaphore_wait 上等待的线程，就能让最先等待的线程执行。
        dispatch_semaphore_signal(semaphore);
    }); 
}

static int initialized = NO;
if (initialized == NO) {
    // 初始化...
    
    initialized = YES; 
}

+ (id)sharedInstance {
    static dispatch_once_t predicate;
    static MyService *instance = nil;
    dispatch_once(&predicate, ^{
        instance = [[self alloc] init];
    });
    
    return instance;
}

dispatch_async(queue, ^{/* loading the file from between 0 to 8191 byte. */});
dispatch_async(queue, ^{/* loading the file from between 8192 to 16383 byte */});
dispatch_async(queue, ^{/* loading the file from between 16384 to 24575 byte */});
dispatch_async(queue, ^{/* loading the file from between 24576 to 32767 byte */});
dispatch_async(queue, ^{/* loading the file from between 32768 to 40959 byte */});
dispatch_async(queue, ^{/* loading the file from between 40960 to 49151 byte */});
dispatch_async(queue, ^{/* loading the file from between 49152 to 57343 byte */});
dispatch_async(queue, ^{/* loading the file from between 57344 to 65535 byte */});

pipe_q = dispatch_queue_create("PipeQ", NULL);

pipe_channel = dispatch_io_create(DISPATCH_IO_STREAM, fd, pipe_q, ^(int err){
    close(fd);
});
*out_fd = fdpair[1];

// dispatch_io_set_low_water 设定一次读取文件块的大小。
dispatch_io_set_low_water(pipe_channel, SIZE_MAX);

// dispatch_io_read 函数使用 Global Dispatch Queue 并行读取。
dispatch_io_read(pipe_channel, 0, SIZE_MAX, pipe_q, ^(bool done, dispatch_data_t pipedata, int err){
    if (err == 0) {
        size_t len = dispatch_data_get_size(pipedata);
        if (len > 0) {
            const char *bytes = NULL;
            char *encoded;
            dispatch_data_t md = dispatch_data_create_map(pipedata, (const void **)&bytes, &len);
            encoded = asl_core_encode_buffer(bytes, len);
            asl_set((aslmsg)merged_msg, ASL_KEY_AUX_DATA, encoded);
            free(encoded);
            _asl_send_message(NULL, merged_msg, -1, NULL);
            asl_msg_release(merged_msg);
            dispatch_release(md);
        }
    }
    if (done) {
        dispatch_semaphore_signal(sem);
        dispatch_release(pipe_channel);
        dispatch_release(pipe_q);
    }
});

__block size_t total = 0;
size_t size = 要读取的字节数;
char *buff = (char *)malloc(size);

// 设置 File Descriptor(sockfd) 为异步读取。
fcntl(sockfd, F_SETFL, O_NONBLOCK);

// 获取 Global Dispatch Queue。
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 创建处理文件读取事件的 Dispatch Source。
dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, sockfd, 0, queue);

// 设定处理事件的 handler。
dispatch_source_set_event_handler(source, ^{
    // 得到可读取的字节数。
    size_t available = dispatch_source_get_data(source);
    // 读取数据。
    int length = read(sockfd, buff, available);
    // 当发生错误时，取消 Dispatch Source。
    if (length < 0) {
        dispatch_source_cancel(source);
    }
    total += length;
    if (total == size) {
        // 此处编写处理数据的代码...
        
        // 处理完成，取消 Dispatch Source。
        dispatch_source_cancel(source);
    }
});

// 设定取消 Dispatch Source 时的 handler。
dispatch_source_set_cancel_handler(source, ^{
    free(buff);
    close(sockfd);
    
    // 释放 Dispatch Source。根据 ARC 环境以及系统版本决定是否要调用 dispatch_release。
    // dispatch_release(source);
});

// 启动 Dispatch Source。
dispatch_resume(source);

// 创建一个处理 DISPATCH_SOURCE_TYPE_TIMER 事件的 Dispatch Source。
// 当经过一段指定的时间时，设定 Main Dispatch Queue 为添加任务的目标任务队列。
dispatch_source_t timer = dispatch_source_create( DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());

// 将定时器设定为 15 秒后触发，设定为不重复模式，并允许延迟 1 秒。
dispatch_source_set_timer(timer, dispatch_time(DISPATCH_TIME_NOW, 15ull * NSEC_PER_SEC), DISPATCH_TIME_FOREVER, 1ull * NSEC_PER_SEC);

// 设定定时器触发时的事件处理 handler。
dispatch_source_set_event_handler(timer, ^{
    NSLog(@"wakeup!");
    
    // 取消 Dispatch Source。
    dispatch_source_cancel(timer); });

// 设定取消 Dispatch Source 时的 handler。
dispatch_source_set_cancel_handler(timer, ^{
    NSLog(@"canceled");
    
    // 释放 Dispatch Source。根据 ARC 环境以及系统版本决定是否要调用 dispatch_release。
    // dispatch_release(timer);
});

// 启动 Dispatch Source。
dispatch_resume(er);