Grand Central Dispatch (GCD) Reference

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。

GCD包括语言特性、运行库和系统改进，提供系统的、全面的改进并支持在iOS和OS X多核硬件上执行并发代码。

在ARC模式下，派遣到GCD中的对象是自动释放的。

1 Functions

1.1 Creating and Managing Queues

// 主队列dispatch_queue_t dispatch_get_main_queue(void);// 获取全局并发队列dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);// 创建一个串行队列dispatch_queue_t dispatch_queue_create( const char *label dispatch_queue_attr_t attr);// 返回通过指定服务质量信息创建的队列的属性信息dispatch_queue_attr_t dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t attr, dispatch_qos_class_t qos_class, int relative_priority);//  当创建队列时指定的标签信息const char * dispatch_queue_get_label(dispatch_queue_t queue);// 为给定的对象绑定一个目标队列void dispatch_set_target_queue(dispatch_object_t object, dispatch_queue_t queue);// 执行已经被提交到主队列中的blockvoid dispatch_main(void);

1.2 Queuing Tasks for Dispatch

GCD为应用程序提供和管理FIFO队列让你的程序可以以block对象的形式来提交你的任务。block提交给调度队列的任务在一个完全由系统管理的线程池中执行。无法保证哪个任务在哪个线程中执行。GCD提供三种类型的队列：

• Main主队列：任务在你的应用程序主线程中被挨个连续的执行。
• Concurrent并发队列：任务被按照FIFO的原则进行取出，但是却可以并发的运行着并可以任何顺序完成。
• Serial连续队列：按照FIFO原则取出并挨个执行，一次执行一个任务。

// 提交一个block到队列中，异步执行，方法会立刻放回void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);// 提交一个APP内定义的方法到队列中异步的执行，方法立即返回void dispatch_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work);// 提交一个block到一个队列中执行并且等待这个block被执行完毕。void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);// 提交一个APP内定义的方法到队列中执行并等待这个方法执行完毕void dispatch_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work);// 在指定的时间执行这个blockvoid dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);// 在指定的时间执行这个程序定义的方法void dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue, void *context, dispatch_function_t work);// 提交一个block到队列中，多次调用。void dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t));// 提交一个程序定义的方法到队列中，多次调用void dispatch_apply_f(size_t iterations, dispatch_queue_t queue, void *context, void (*work)(void *, size_t));// 执行一次该block对象，并且在整个程序的生命周期内只执行这么一次void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);// 执行一次该程序定义的方法，并且在整个程序的生命周期内只执行这么一次void dispatch_once_f(dispatch_once_t *predicate, void *context, dispatch_function_t function);

1.3 Using Dispatch Groups

分组块允许聚合同步。你的应用可以提交多个block并跟踪它们的完成，甚至于它们在不同的队列中执行。

// 创建一个可关联block的组dispatch_group_t dispatch_group_create(void);// 异步在队列中执行block，并于指定的调度组关联起来void dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);// 异步在队列中执行应用中的方法，并于指定的调度组关联起来void dispatch_group_async_f(dispatch_group_t group, dispatch_queue_t queue, void *context, dispatch_function_t work);// 设置队列超时时间long dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);// 组内代码执行完毕后执行blockvoid dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);// 组内代码执行完毕后执行应用内方法void dispatch_group_notify_f(dispatch_group_t group, dispatch_queue_t queue, void *context, dispatch_function_t work);// 明确指示一个新的block进入到了调度组void dispatch_group_enter(dispatch_group_t group);// 明确指示block在调度组中执行完毕void dispatch_group_leave(dispatch_group_t group);

1.4 Managing Dispatch Objects

GCD提供调度对象接口允许你的程序来管理诸如处理内存管理、暂停和恢复执行、定义对象环境和打印任务数据等。调度对象必须手动的持有retain和释放release，否则不会被回收。

// 调度对象增加引用计数void dispatch_retain(dispatch_object_t object);// 调度对象减少引用计数void dispatch_release(dispatch_object_t object);// 获取调度对象的应用程序上下文void *dispatch_get_context(dispatch_object_t object);// 设置调度对象的应用程序上下文void dispatch_set_context(dispatch_object_t object, void *context);// 设置调度对象的终结函数void dispatch_set_finalizer_f(dispatch_object_t object, dispatch_function_t finalizer);// 调度对象暂停void dispatch_suspend(dispatch_object_t object);// 调度对象恢复运行void dispatch_resume(dispatch_object_t object);// 设置对象超时时间long dispatch_wait(void *object, dispatch_time_t timeout);// 调度对象执行完毕的通知void dispatch_notify(void *object, dispatch_object_t queue, dispatch_block_t notification_block);// 取消执行void dispatch_cancel(void *object);// 判断能否取消执行long dispatch_testcancel(void *object);

1.5 Using Semaphores

调度信号是一个传统的计数信号量的高效实现，可用于实现同步代码。当线程需要堵塞运行时，调用信号会直接调用内核。

// 创建调度信号 value=0暂停、大于0执行dispatch_semaphore_t dispatch_semaphore_create(long value);// 递减计数信号量。如果得到的值小于零，该功能在FIFO为信号发生之前回来。并设置超时时间long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout);// 增量计数信号量。如果先前的值小于零，该功能目前在dispatch_semaphore_wait唤醒一个线程long dispatch_semaphore_signal(dispatch_semaphore_t dsema);

1.6 Using Barriers

调度障碍允许在并发队列中设置一个同步点。在同步点之前的所有代码执行完毕时，同步点后的代码才会执行。

// 异步执行的障碍blockvoid dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);// 异步执行的障碍函数void dispatch_barrier_async_f(dispatch_queue_t queue, void *context, dispatch_function_t work);// 同步执行的障碍blockvoid dispatch_barrier_sync(dispatch_queue_t queue, dispatch_block_t block);// 同步执行的障碍函数void dispatch_barrier_sync_f(dispatch_queue_t queue, void *context, dispatch_function_t work);

1.7 Managing Dispatch Sources

GCD提供了一系列接口用于检测GCD的相关运行状态。

// 创建监听源dispatch_source_t dispatch_source_create(dispatch_source_type_t type, uintptr_t handle, unsigned long mask, dispatch_queue_t queue);// 设置事件处理程序-blockvoid dispatch_source_set_event_handler(dispatch_source_t source, dispatch_block_t handler);// 设置事件处理程序-函数void dispatch_source_set_event_handler_f(dispatch_source_t source, dispatch_function_t handler);// 取消事件处理程序-blockvoid dispatch_source_set_cancel_handler(dispatch_source_t source, dispatch_block_t handler);// 取消事件处理程序-函数void dispatch_source_set_cancel_handler_f(dispatch_source_t source, dispatch_function_t handler);// 取消调度源void dispatch_source_cancel(dispatch_source_t source);// 判断调度源是否已取消long dispatch_source_testcancel(dispatch_source_t source);// 返回dispatch source管理的底层系统数据类型，即调用dispatch_source_create的第二个参数uintptr_t dispatch_source_get_handle(dispatch_source_t source);// 得到调用dispatch_source_create的第三个参数unsigned long dispatch_source_get_mask(dispatch_source_t source);// 获取dispatch_source_merge_data的第二个参数unsigned long dispatch_source_get_data(dispatch_source_t source);// 合并dispatch源数据，在dispatch源的block中.类型DISPATCH_SOURCE_TYPE_DATA_ADD or DISPATCH_SOURCE_TYPE_DATA_ORvoid dispatch_source_merge_data(dispatch_source_t source, unsigned long value);// 设置定时器void dispatch_source_set_timer(dispatch_source_t source, dispatch_time_t start, uint64_t interval, uint64_t leeway);// 注册事件源启动监听，即调用dispatch_resume()方法时调用blockvoid dispatch_source_set_registration_handler(dispatch_source_t source, dispatch_block_t handler);// 注册事件源启动监听，即调用dispatch_resume()方法时调用函数void dispatch_source_set_registration_handler_f(dispatch_source_t source, dispatch_function_t handler);

1.8 Using the Dispatch I/O Convenience API

调度I / O方便的接口，可以让您执行文件描述符的异步读写操作。此接口支持基于流的语义访问文件描述符的内容。

// 异步读取指定的描述符void dispatch_read(dispatch_fd_t fd, size_t length, dispatch_queue_t queue, void (^handler)(dispatch_data_t data, int error));// 异步写入指定的描述符void dispatch_write(dispatch_fd_t fd, dispatch_data_t data, dispatch_queue_t queue, void (^handler)(dispatch_data_t data, int error));

1.9 Using the Dispatch I/O Channel API

dispatch I/O 以流的方式管理文件的相关操作。

// 创建io通道dispatch_io_t dispatch_io_create(dispatch_io_type_t type, dispatch_fd_t fd, dispatch_queue_t queue, void (^cleanup_handler)(int error));// 通过路径创建IOS通道dispatch_io_t dispatch_io_create_with_path(dispatch_io_type_t type, const char *path, int oflag, mode_t mode, dispatch_queue_t queue, void (^cleanup_handler)(int error));// 通过io创建IO通道dispatch_io_t dispatch_io_create_with_io(dispatch_io_type_t type, dispatch_io_t io, dispatch_queue_t queue, void (^cleanup_handler)(int error));// 读取文件内容void dispatch_io_read(dispatch_io_t channel, off_t offset, size_t length, dispatch_queue_t queue, dispatch_io_handler_t io_handler);// 写入文件内容void dispatch_io_write(dispatch_io_t channel, off_t offset, dispatch_data_t data, dispatch_queue_t queue, dispatch_io_handler_t io_handler);// 关闭IO通道读或写的操作void dispatch_io_close(dispatch_io_t channel, dispatch_io_close_flags_t flags);// 添加io通道操作完毕的block回调void dispatch_io_barrier(dispatch_io_t channel, dispatch_block_t barrier);// 获取dispatch_io_create的第二个参数dispatch_fd_t dispatch_io_get_descriptor(dispatch_io_t channel);// io通道设置高优先级void dispatch_io_set_high_water(dispatch_io_t channel, size_t high_water);// io通道设置低优先级void dispatch_io_set_low_water(dispatch_io_t channel, size_t low_water);// 设置处理间隔void dispatch_io_set_interval(dispatch_io_t channel, uint64_t interval, dispatch_io_interval_flags_t flags);

1.10 Managing Dispatch Data Objects

调度数据对象提供一个接口来管理基于内存的数据缓冲区。客户端访问数据缓冲区时将它看做一个连续的内存块，但缓冲区在内部可能由多个不连续的内存块组成。

// 在指定的缓冲区创建调度对象dispatch_data_t dispatch_data_create(const void *buffer, size_t size, dispatch_queue_t queue, dispatch_block_t destructor);// 获取对象占用的缓冲区大小size_t dispatch_data_get_size(dispatch_data_t data);// 通过指定的缓存对象和缓存创建一个新的缓存对象dispatch_data_t dispatch_data_create_map(dispatch_data_t data, const void **buffer_ptr, size_t *size_ptr);// 合并缓存对象成新的缓存对象dispatch_data_t dispatch_data_create_concat(dispatch_data_t data1, dispatch_data_t data2);// 获取缓存对象指定位置的数据dispatch_data_t dispatch_data_create_subrange(dispatch_data_t data, size_t offset, size_t length);// 遍历对象bool dispatch_data_apply(dispatch_data_t data, dispatch_data_applier_t applier);// 查找包含指定对象所表示的区域之间的指定位置的连续内存区域，并返回表示该区域的内部调度数据对象的副本dispatch_data_t dispatch_data_copy_region(dispatch_data_t data, size_t location, size_t *offset_ptr);

1.11 Managing Time

// 生成时间=when+deltadispatch_time_t dispatch_time(dispatch_time_t when, int64_t delta);// 通过一个结构体计算绝对时间dispatch_time_t dispatch_walltime(const struct timespec *when, int64_t delta);

1.12 Managing Queue-Specific Context Data

// 为队列设置标示void dispatch_queue_set_specific(dispatch_queue_t queue, const void *key, void *context, dispatch_function_t destructor);// 获取指定队列标示void *dispatch_queue_get_specific(dispatch_queue_t queue, const void *key);// 获取当前队列标示void *dispatch_get_specific(const void *key);

 

---

Appendix

Related Documentation

Grand Central Dispatch (GCD) Reference

Concurrency Programming Guide

iOS学习篇之Grand Central Dispatch（GCD）

Revision History

时间 描述 2016-08-31 博文完成

Copyright

CSDN：http://blog.csdn.net/y550918116j

GitHub：https://github.com/937447974