Serial queues (also known as private dispatch queues) execute one task at a time in the order in which they are added to the queue.The currently executing task runs on a distinct thread (which can vary from task to task) that is managed by the dispatch queue.

NSLog(@"1"); // 死锁，只会输出1
dispatch_sync(currentQueue, ^{NSlog(@"2"); // block也提交到当前线程对应的队列
});
NSlog(@"3");

// 依次输出1、2、3
NSLog(@"1");
dispatch_sync(notCurrentQueue, ^{NSlog(@"2"); // block提交到另外一个线程对应的队列
});
NSlog(@"3");   

dispatch_queue_t dispatch_queue_create(const char *_Nullable label, dispatch_queue_attr_t _Nullable attr);
// label：队列的唯一标识，方便调试
// attr：队列类型，NULL或者DISPATCH_QUEUE_SERIAL表示串行，DISPATCH_QUEUE_CONCURRENT表示并行
dispatch_queue_t serialQueue = dispatch_queue_create("com.tencent.wechat.file", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.tencent.wechat.network",DISPATCH_QUEUE_CONCURRENT);　　

dispatch_queue_t serialMainQueue = dispatch_get_main_queue();

dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);
// identifier：队列优先级
// flags：通常填0
dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

void dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);
// 3秒后提交block到主队列，这个时间并不精确，得看当时线程的繁忙程度
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{});

dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// blk1, blk2, blk3并行执行
dispatch_async(globalConcurrentQueue, blk1);
dispatch_async(globalConcurrentQueue, blk2);
dispatch_async(globalConcurrentQueue, blk3);
// blk1, blk2, blk3全部执行完，才开始执行blk4
dispatch_barrier_async(globalConcurrentQueue, blk4);
// blk4执行完，才开始并行执行blk5, blk6
dispatch_async(globalConcurrentQueue, blk5);
dispatch_async(globalConcurrentQueue, blk6);

dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, q, ^(size_t iter) {NSLog(@"iteration[%zu]", iter);
});
NSLog(@"done");输出：
iteration[3]
iteration[2]
iteration[0]
iteration[4]
iteration[1]
iteration[5]
iteration[9]
iteration[8]
iteration[7]
iteration[6]
done // 最后输出一定是这个 

// 创建信号量，初始值可以不为1
dispatch_semaphore_t s = dispatch_semaphore_create(1);
// 阻塞等待信号量大于等于1
dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER);
// 信号量减1，开始执行临界区代码/* 临界区代码 */// 临界区代码执行结束，信号量+1，最先等待信号量的线程得到执行
dispatch_semaphore_signal(s);

// 获取文件描述符
dispatch_fd_t fd = open(file_path, O_RDWR);
// 创建用于处理dispatch io block的队列
dispatch_queue_t queue = dispatch_queue_create(queue_name, NULL);
// 创建dispatch io，绑定文件描述符
dispatch_io_t io = dispatch_io_create(DISPATCH_IO_STREAM, fd, queue, ^(int error) {// 异常close(fd);
});
// 设置一次最多读取的字节数
dispatch_io_set_high_water(io, size);
// 这里书上说会使用global queue来并发读，但是实践没看出来，懂的同学请多多指教
dispatch_io_read(io, 0, max_size, queue, ^(bool done, dispatch_data_t  _Nullable data, int error) {// dispatch_data_t转NSStringdispatch_data_apply(data, ^bool(dispatch_data_t region, size_t offset, const void *buffer, size_t size) {NSString *sData = [[NSString alloc] initWithBytes:buffer length:size encoding: NSUTF8StringEncoding];return true;});
});

// 创建source
dispatch_source_t dispatch_source_create(dispatch_source_type_t type, uintptr_t handle, unsigned long mask, dispatch_queue_t queue);
// 取消source，已经在执行的handler会继续执行完，还没执行的不再执行
void dispatch_source_cancel(dispatch_source_t source);
// 事件source发生时，执行handler
void dispatch_source_set_event_handler(dispatch_source_t source, dispatch_block_t handler);
// 取消source时，执行handler
void dispatch_source_set_cancel_handler(dispatch_source_t source, dispatch_block_t handler);
// 启动source
void dispatch_resume(dispatch_object_t object);