*Dispatch是一个抽象模型，用于通过简单但
*强大的API。
*在核心部分，dispatch提供了串行FIFO队列，块可以被发送到这些队列
*已提交。提交到这些调度队列的块在池上调用
*由系统完全管理的线程数。未就
*将在哪个线程上调用块；然而，我们保证
*一次将调用提交给FIFO调度队列的一个块。
*当多个队列有要处理的块时，系统可以自由地
*分配其他线程以同时调用块。当
*队列变为空，这些线程将自动释放。
类型定义 dispatch_queue_t
*调度队列调用提交给它们的工作项。
*串行队列（请参阅dispatch_queue_serial_t）。
*系统管理一组线程，这些线程处理调度队列并调用
*提交给他们的工作项。
*从概念上讲，调度队列可能有自己的执行线程，并且
*队列之间的交互是高度异步的。
*调度队列通过调用Dispatch_retain()和
*dispatch_release()。提交到队列的挂起工作项也包含
*引用队列，直到它们完成为止。一旦所有引用
*队列已释放，系统将释放队列。
（调度DECL）DISPATCH_DECL(dispatch_queue);（调度队列）
类型定义 dispatch_queue_global_t
*调度全局并发队列是围绕系统线程的抽象
*调用提交到调度队列的工作项的池。
*调度全局并发队列在
*系统管理的线程池。系统将决定有多少线程
*根据需求和系统负载分配到此池。特别是，
*系统尝试保持此资源的良好并发级别，
*并将在太多现有工作线程阻塞时创建新线程
*系统调用。
*全局并发队列是一种共享资源，因此它是
*此资源的每个用户都有责任不提交无限制的
*此池的工作量，尤其是可能阻塞的工作量
*导致系统产生大量线程（又称线程
*爆炸）。
*提交到全局并发队列的工作项没有排序
*关于提交顺序和提交工作项目的担保
*可以同时调用这些队列。
*Dispatch global concurrent queues是众所周知的全局对象
*由dispatch_get_global_queue()返回。无法修改这些对象。
*调用dispatch_suspend()、dispatch_resume()、dispatch_set_context()等。，
*与此类型的队列一起使用时将不起作用。
（调度DECL子类）DISPATCH_DECL_SUBCLASS(dispatch_queue_global, dispatch_queue);
类型定义 dispatch_queue_serial_t
*调度串行队列调用在FIFO中串行提交给它们的工作项
*订单。
*调度序列队列是工作项可以访问的轻量级对象
*提交以FIFO顺序调用。串行队列将只调用一个
*一次调用workitem，但独立的串行队列可能各自调用其工作
*相互关联的项目。
*串行队列可以彼此为目标（请参阅dispatch_set_target_queue()）。这个
*队列层次结构底部的串行队列提供排除
*上下文：最多有一个工作项提交到以下队列中的任何队列
*教权会在任何给定的时间运行。
*这种层次结构提供了组织应用程序的自然构造
*周围的子系统。
*通过传递派生自的调度队列属性来创建串行队列
* DISPATCH_QUEUE_SERIAL to dispatch_queue_create_with_target().
（调度DECL子类）DISPATCH_DECL_SUBCLASS(dispatch_queue_main, dispatch_queue_serial);
类型定义 dispatch_queue_concurrent_t
*调度并发队列调用并发提交给它们的工作项，
*并承认屏障工作项的概念。
*调度并发队列是轻量级对象，常规和
*可提交屏障工作项。在中调用屏障工作项
*在FIFO顺序中排除任何其他类型的工作项。
*可以为同一并发队列并发调用常规工作项，
*以任何顺序。但是，在任何
*已调用在他们之前提交的屏障工作项。
*换句话说，如果串行队列等效于调度中的互斥体
*实际上，并发队列相当于读写器锁，其中
*常规项目是读者，障碍是作者。
*通过传递派生的调度队列属性来创建并发队列
*从DISPATCH_QUEUE_CONCURRENT到DISPATCH_QUEUE_create_with_target()。
*注意事项：
*此时调度并发队列不实现优先级反转
*调用低优先级常规工作项（读卡器）时避免
*和正在阻止调用更高优先级的屏障（writer）。
（调度DECL子类）DISPATCH_DECL_SUBCLASS(dispatch_queue_concurrent, dispatch_queue);
__BEGIN_DECLS
函数 dispatch_async
*@摘要
*提交块以在调度队列上异步执行。
*@讨论
*dispatch_async()函数是提交的基本机制
*阻止调度队列。
*对dispatch_async()的调用总是在块执行完后立即返回
*已提交，并且从不等待调用该块。
*目标队列确定是串行调用还是
*与提交到同一队列的其他块并发。
*串行队列彼此并行处理。
*@参数队列
*将块提交到的目标调度队列。
*系统将在目标队列上保留引用，直到阻塞
*已完成。
*此参数中传递NULL的结果未定义。
*@参数块
*要提交到目标调度队列的块。此函数执行
*代表调用方执行Block_copy()和Block_release()。
*此参数中传递NULL的结果未定义。
#ifdef __BLOCKS__
API 可用(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
void
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
#endif
函数 dispatch_async_f
*@摘要
*提交用于在调度队列上异步执行的函数。
*@讨论
*有关详细信息，请参阅dispatch_async()。
*@参数队列
*将函数提交到的目标调度队列。
*系统将在目标队列上保留引用，直到函数
*已返回。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_async_f()。
*此参数中传递NULL的结果未定义。
API 可用（macos（10.6）、ios（4.0））
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_async_f(dispatch_queue_t queue,
void *_Nullable context, dispatch_function_t work);
函数 dispatch_sync
*@摘要
*提交块以在调度队列上同步执行。
*@讨论
*但是，将工作项提交到dispatch_async()之类的调度队列
*dispatch_sync()在工作项完成之前不会返回。
*提交到具有dispatch_sync()的队列的工作项不遵守某些
*调用时该队列的队列属性（例如自动释放频率
*和QOS类）。
*将导致以当前队列为目标调用dispatch_sync()
*处于死锁状态。dispatch_sync()的使用也受到相同的限制
*使用互斥锁可能导致的多方死锁问题。
*首选使用dispatch_async()。
*与dispatch_async()不同，在目标队列上不执行retain。因为
*对该函数的调用是同步的，dispatch_sync()借用
*调用方的引用。
*作为一种优化，dispatch_sync()调用线程上的工作项
*已提交工作项，除非传递的队列是主队列或
*以其为目标的队列（请参阅dispatch_queue_main\t，
*dispatch_set_target_queue()）。
*@参数队列
*将块提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数块
*要在目标调度队列上调用的块。
*此参数中传递NULL的结果未定义。
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
void
dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);
#endif
函数 dispatch_sync_f
*@摘要
*提交用于在调度队列上同步执行的函数。
*@讨论
*有关详细信息，请参阅dispatch_sync()。
*@参数队列
*将函数提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_sync_f()。
*此参数中传递NULL的结果未定义。
API可用（macos（10.6）、ios（4.0））
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_sync_f(dispatch_queue_t queue,
void *_Nullable context, dispatch_function_t work);
dispatch_sync_f（dispatch_queue_t queue，
void*_Nullable context，dispatch_function\t work）；
/*@函数dispatch_async_and_wait
*@摘要
*提交块以在调度队列上同步执行。
*@讨论
*但是，将工作项提交到dispatch_async()之类的调度队列
*dispatch_async_and_wait()在工作项完成之前不会返回。
*与dispatch_sync系列的函数一样，dispatch_async\u和_wait()是
*受制于死锁（有关详细信息，请参阅dispatch_sync()。
*然而，dispatch_async\u和_wait()不同于
*dispatch_sync系列有两种基本方式：如何尊重队列
*属性以及它如何选择调用workitem的执行上下文。
*与dispatch_sync()的差异</b>
*提交到具有dispatch_async\u和_wait()的队列的工作项全部观察
*调用时该队列的队列属性（包括自动释放频率
*或QOS类）。
*当运行时启动线程以调用异步工作项时
*已提交到指定队列，该服务线程也将
*用于执行提交到队列的同步工作
*dispatch_async_and_wait()。
*但是，如果运行时没有启动线程来服务指定的
*队列（因为它没有排队的工作项，或者只有同步工作项），
*然后dispatch_async_and_wait()将调用调用线程上的工作项，
*类似于dispatch_sync系列中函数的行为。
*例外情况是，如果提交工作的队列不是目标队列
*全局并发队列（例如，因为它以主队列为目标），
*那么线程调用永远不会调用workitem
*dispatch_async_and_wait()。
*换句话说，dispatch_async_and_wait()类似于提交
*将dispatch_block_create()d工作项发送到队列，然后等待它，如
*如下面的代码示例所示。但是，dispatch_async_and_wait()是
*当不需要执行新线程时，效率会显著提高
*workitem（因为它将使用提交线程的堆栈，而不是
*需要堆分配）。
*<代码>
* dispatch_block_t b = dispatch_block_create(0, block);
* dispatch_async(queue, b);
* dispatch_block_wait(b, DISPATCH_TIME_FOREVER);
* Block_release(b);
*</代码>
*@参数队列
*将块提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数块
*要在目标调度队列上调用的块。
*此参数中传递NULL的结果未定义。
*/
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
void
dispatch_async_and_wait(dispatch_queue_t queue,
DISPATCH_NOESCAPE dispatch_block_t block);
#endif
*@函数dispatch_async_and_wait_f
*@摘要
*提交用于在调度队列上同步执行的函数。
*@讨论
*有关详细信息，请参阅dispatch_async_and_wait()。
*@参数队列
*将函数提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_async\u和_wait_f()。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_async_and_wait_f(dispatch_queue_t queue,
void *_Nullable context, dispatch_function_t work);
#if defined(__APPLE__) && \
(defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && \
__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_7_0) || \
(defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_9)
#define DISPATCH_APPLY_AUTO_AVAILABLE 0
#define DISPATCH_APPLY_QUEUE_ARG_NULLABILITY _Nonnull
#else
#define DISPATCH_APPLY_AUTO_AVAILABLE 1
#define DISPATCH_APPLY_QUEUE_ARG_NULLABILITY _Nullable
#endif
/*@持续 DISPATCH_APPLY_AUTO
*@摘要
*传递给dispatch_apply() 或 dispatch_apply_f()的常量或请求
*系统自动使用与配置匹配的工作线程
*当前线程尽可能接近。
*@讨论
*提交块进行并行调用时，将此常量作为
*queue参数将自动使用全局并发队列
*与调用者的服务质量最为匹配。
*不应假设哪个全局并发队列将
*实际使用。
*使用此常量可向后部署到macOS 10.9、iOS 7.0和任何tvOS或
*watchOS版本。
*/
#if DISPATCH_APPLY_AUTO_AVAILABLE
#define DISPATCH_APPLY_AUTO ((dispatch_queue_t _Nonnull)0)
#endif
/*
*@函数dispatch_apply
*@摘要
*将块提交到调度队列以进行并行调用。
*@讨论
*将块提交到调度队列以进行并行调用。此函数
*等待任务块完成，然后返回。如果指定的队列
*如果是并发的，则可以并发调用该块，因此必须
*确保可重入安全。
*块的每次调用都将传递当前迭代索引。
*@参数迭代次数
*要执行的迭代次数。
*@参数队列
*将块提交到的调度队列。
*要传递的首选值是DISPATCH_APPLY_AUTO to automatically use
*适用于调用线程的队列。
*@参数块
*要调用指定迭代次数的块。
*此参数中传递NULL的结果未定义。
*此函数用于执行输入块的Block_copy() 和 Block_release()
*代表呼叫者。为了省去额外的块分配，
*可以改用dispatch_apply_f。
*/
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_apply(size_t iterations,
dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
DISPATCH_NOESCAPE void (^block)(size_t iteration));
#endif
/*
*@函数dispatch_apply_f
*@摘要
*将函数提交到调度队列以进行并行调用。
*@讨论
*有关详细信息，请参阅dispatch_apply() 。
*@参数迭代次数
*要执行的迭代次数。
*@参数队列
*函数提交到的调度队列。
*要传递的首选值是DISPATCH_APPLY_AUTO to automatically use
*适用于调用线程的队列。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在指定队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_apply_f()。传递给此函数的第二个参数是
*迭代的当前索引。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NONNULL4 DISPATCH_NOTHROW
void
dispatch_apply_f(size_t iterations,
dispatch_queue_t DISPATCH_APPLY_QUEUE_ARG_NULLABILITY queue,
void *_Nullable context, void (*work)(void *_Nullable context, size_t iteration));
/*
*@函数dispatch_get_current_queue
*@摘要
*返回当前正在运行块的队列。
*@讨论
*返回当前正在运行块的队列。
*已提交的块，它将返回默认的并发队列。
*建议仅用于调试和记录目的：
*代码不得对返回的队列进行任何假设，除非
*是全局队列之一或代码本身创建的队列。
*代码不能假定队列上的同步执行是安全的
*如果该队列不是
*dispatch_get_current_queue().。
*在主线程上调用dispatch_get_current_queue()时，它可能
*或可能返回的值与dispatch_get_main_queue(). 的值不同。比较
*这两种方法不是测试代码是否在
*主线程（请参阅dispatch_assert_queue()和dispatch_assert_queue_not()）。
*此函数已弃用，将在将来的版本中删除。
*@结果
*返回当前队列。
*/
API 已弃用API_DEPRECATED("unsupported interface", macos(10.6,10.9), ios(4.0,6.0))
DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
dispatch_queue_t
dispatch_get_current_queue(void);
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT
struct dispatch_queue_s _dispatch_main_q;
/*
函数dispatch_get_main_queue
*@摘要
*返回绑定到主线程的默认队列。
*@讨论
*为了调用提交到主队列的块，应用程序必须
*调用dispatch_main()、NSApplicationMain()，或在main上使用CFRunLoop
*螺纹。
*主队列用于在应用程序上下文中与
*主线程和主运行循环。
*因为主队列的行为不完全像常规的串行队列，
*在非UI应用程序的流程中使用时，可能会产生不必要的副作用
*（守护进程）。对于此类进程，应避免使用主队列。
*@请参阅dispatch_queue_main\t
*@结果
*返回主队列。此队列是代表自动创建的
*调用main()之前的主线程。
*/
DISPATCH_INLINE DISPATCH_ALWAYS_INLINE DISPATCH_CONST DISPATCH_NOTHROW
dispatch_queue_main_t
dispatch_get_main_queue(void)
{
return DISPATCH_GLOBAL_OBJECT(dispatch_queue_main_t, _dispatch_main_q);
}
/*
typedef dispatch_queue_priority_t
*dispatch_queue_priority的类型
*@常量DISPATCH_QUEUE_PRIORITY_HIGH
*调度到队列的项目将以高优先级运行，
*即队列将在
*任何默认优先级或低优先级队列。
*@constant DISPATCH_QUEUE_PRIORITY\u默认值
*调度到队列的项目将在默认情况下运行
*优先级，即队列将被安排执行
*在调度了所有高优先级队列之后，但是
*在计划任何低优先级队列之前。
*@常量DISPATCH_QUEUE_PRIORITY_LOW
*调度到队列的项目将以低优先级运行，
*也就是说，队列最终将被安排执行
*默认优先级和高优先级队列
*已计划。
*@常量DISPATCH_QUEUE_PRIORITY_BACKGROUND
*调度到队列的项目将以后台优先级运行，即队列
*将安排在所有高优先级队列完成后执行
*已计划，系统将在具有
*符合setpriority（2）的后台状态（即磁盘i/O被限制，并且
*线程的调度优先级设置为最低值）。
*/
#define DISPATCH_QUEUE_PRIORITY_HIGH 2
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
typedef long dispatch_queue_priority_t;
/*
函数dispatch_get_global_queue
*@摘要
*返回给定服务质量的已知全局并发队列
*类别。
*@讨论
*请参阅 dispatch_queue_global_t.
*@参数标识符
*qos_class_t 中定义的服务质量类别或中定义的优先级
*dispatch_queue_priority_t.
*建议使用服务质量等级值来确定
*著名的全局并发队列：
* - QOS_CLASS_USER_INTERACTIVE
* - QOS_CLASS_USER_INITIATED
* - QOS_CLASS_DEFAULT
* - QOS_CLASS_UTILITY
* - QOS_CLASS_BACKGROUND
*全局并发队列仍然可以通过其优先级来识别，
*映射到以下QOS类：
* - DISPATCH_QUEUE_PRIORITY_HIGH: QOS_CLASS_USER_INITIATED
* - DISPATCH_QUEUE_PRIORITY_DEFAULT: QOS_CLASS_DEFAULT
* - DISPATCH_QUEUE_PRIORITY_LOW: QOS_CLASS_UTILITY
* - DISPATCH_QUEUE_PRIORITY_BACKGROUND: QOS_CLASS_BACKGROUND
*@参数标志
*保留供将来使用。传递除零以外的任何值可能会导致
*空返回值。
*@结果
*返回请求的全局队列，如果请求的全局队列
*不存在。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_CONST DISPATCH_WARN_RESULT DISPATCH_NOTHROW
dispatch_queue_global_t
dispatch_get_global_queue(intptr_t identifier, uintptr_t flags);
/*
typedef dispatch_queue_attr_t
*@摘要
*调度队列的属性。
*/
DISPATCH_DECL(dispatch_queue_attr);
/*
const DISPATCH_QUEUE_SERIAL
*@讨论
*可用于创建调用块的调度队列的属性
*按FIFO顺序串行。
*请参阅dispatch_queue_serial_t.
*/
#define DISPATCH_QUEUE_SERIAL NULL
/*
const DISPATCH_QUEUE_SERIAL_INACTIVE
*@讨论
*可用于创建调用块的调度队列的属性
*按FIFO顺序串行，并且最初处于非活动状态。
*请参阅dispatch_queue_attr_make_initially_inactive().
*/
#define DISPATCH_QUEUE_SERIAL_INACTIVE \
dispatch_queue_attr_make_initially_inactive(DISPATCH_QUEUE_SERIAL)
/*
const DISPATCH_QUEUE_CONCURRENT (并发)
*@讨论
*可用于创建可调用的调度队列的属性
*同时阻塞，并支持随调度提交的屏障阻塞
*屏障API。
*请参阅dispatch_queue_concurrent_t。
*/
#define DISPATCH_QUEUE_CONCURRENT \
DISPATCH_GLOBAL_OBJECT(dispatch_queue_attr_t, \
_dispatch_queue_attr_concurrent)
API_AVAILABLE(macos(10.7), ios(4.3))
DISPATCH_EXPORT
struct dispatch_queue_attr_s _dispatch_queue_attr_concurrent;
/*
const DISPATCH_QUEUE_CONCURRENT_INACTIVE (未激活)
*@讨论
*可用于创建可调用的调度队列的属性
*同时阻塞，并支持随调度提交的屏障阻塞
*barrier API，并且该API最初处于非活动状态。
*请参阅dispatch_queue_attr_make_initially_inactive().
*/
#define DISPATCH_QUEUE_CONCURRENT_INACTIVE \
dispatch_queue_attr_make_initially_inactive(DISPATCH_QUEUE_CONCURRENT)
/*
函数dispatch_queue_attr_make_initially_inactive
*@摘要
*返回可提供给dispatch_queue_create()）的属性值
*或dispatch_queue_create_with_target()，以使创建的队列
*最初处于非活动状态。
*@讨论
*调度队列可以在非活动状态下创建。处于此状态的队列
*必须在调用与之关联的任何块之前激活。
*无法释放处于非活动状态的队列，dispatch_activate()必须为
*在最后一次引用使用此属性创建的队列之前调用
*已发布。
*处于非活动状态的队列的目标队列可以使用
*dispatch_set_target_queue()。不再允许更改目标队列
*一旦初始非活动队列被激活。
*@参数属性
*要与初始非活动属性组合的队列属性值。
*@返回
*返回可提供给dispatch_queue_create()的属性值
*和dispatch_queue_create_with_target()。
*新值将“attr”参数指定的属性与
*初始非活动属性。
*/
API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_PURE DISPATCH_NOTHROW
dispatch_queue_attr_t
dispatch_queue_attr_make_initially_inactive(
dispatch_queue_attr_t_Nullableattr);
/*!
*@const DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL
*@讨论
*使用此属性创建的调度队列在FIFO中串行调用块
*顺序，并围绕异步提交给它的任何块的执行
*相当于一个单独的目标-C
*范围。
*请参见 dispatch_queue_attr_make_with_autorelease_frequency().
*/
#define DISPATCH_QUEUE_SERIAL_WITH_AUTORELEASE_POOL \
dispatch_queue_attr_make_with_autorelease_frequency(\
DISPATCH_QUEUE_SERIAL, DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM)
/*!
*@const DISPATCH_QUEUE_CONCURRENT_WITH_AUTORELEASE_POOL
*@讨论
*使用此属性创建的调度队列在FIFO中串行调用块
*顺序，并围绕异步提交给它的任何块的执行
*相当于一个单独的目标-C
*范围。
*请参见 dispatch_queue_attr_make_with_autorelease_frequency().
*/
#define DISPATCH_QUEUE_CONCURRENT_WITH_AUTORELEASE_POOL \
dispatch_queue_attr_make_with_autorelease_frequency(\
DISPATCH_QUEUE_CONCURRENT, DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM)
/*!
*@typedef dispatch_autorelease_frequency_t
* Values to pass to the dispatch_queue_attr_make_with_autorelease_frequency()
*功能。
*@const DISPATCH_AUTORELEASE_FREQUENCY_INHERIT
*具有此自动释放频率的调度队列继承
*他们的目标队列。这是手动创建队列的默认行为。
*@const DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM
*具有此自动释放频率的调度队列推送并弹出自动释放
*围绕提交给它的每个块的执行进行聚合
*异步。
*@参见 dispatch_queue_attr_make_with_autorelease_frequency().
*@const DISPATCH_AUTORELEASE_FREQUENCY_NEVER
*具有此自动释放频率的调度队列从不设置个人
*自动释放提交给它的块的执行周围的池
*异步。这是全局并发队列的行为。
*/
DISPATCH_ENUM(dispatch_autorelease_frequency,unsignedlong,
DISPATCH_AUTORELEASE_FREQUENCY_INHERIT DISPATCH_ENUM_API_AVAILABLE(
macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 0,
DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM DISPATCH_ENUM_API_AVAILABLE(
macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 1,
DISPATCH_AUTORELEASE_FREQUENCY_NEVER DISPATCH_ENUM_API_AVAILABLE(
macos(10.12), ios(10.0), tvos(10.0), watchos(3.0)) = 2,
);
/*!
*@作用 dispatch_queue_attr_make_with_autorelease_frequency
*@摘要
*返回具有自动释放频率的调度队列属性值
*设置为指定值。
*@讨论
*队列使用每工作项自动释放频率时（直接
*或从其目标队列继承），异步提交给
*此队列（通过dispatch_async()、dispatch_barrier_async()，
*dispatch_group_notify()等…）就像被一个人包围一样执行
*目标-C自动释放池范围。
*自动释放频率对提交的块没有影响
*同步到队列（通过dispatch_sync()、dispatch_barrier_sync()）。
*全局并发队列具有DISPATCH_AUTORELEASE_FREQUENCY_NEVER
*行为。手动创建的调度队列使用
*默认情况下，DISPATCH_AUTORELEASE_FREQUENCY_INHERIT。
*使用此属性创建的队列在
*已激活。请参阅dispatch_set_target_queue()和dispatch_activate()。
*@参数属性
*要与指定的自动释放组合的队列属性值
*频率或空值。
*@参数频率
*请求的自动释放频率。
*@返回
*返回可提供给dispatch_queue_create()的属性值
*如果请求的自动释放频率无效，则为NULL。
*此新值将“attr”参数指定的属性与
*选择的自动释放频率。
*/
API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_PURE DISPATCH_NOTHROW
dispatch_queue_attr_t
dispatch_queue_attr_make_with_autorelease_frequency(
dispatch_queue_attr_t_Nullableattr,
dispatch_autorelease_frequency_t frequency);
/*
数 dispatch_queue_attr_make_with_qos_class
*@摘要
*返回可提供给dispatch_queue_create()的属性值
*或dispatch_queue_create_with_target()，以分配QOS类和
*队列的相对优先级。
*@讨论
*当以这种方式指定时，QOS类和相对优先级将
*优先于从调度队列的目标队列继承的优先级（如果
*任何）只要不会导致较低的QOS级别和相对优先级。
*全局队列优先级映射到以下QOS类：
*-DISPATCH_QUEUE_PRIORITY_HIGH：QOS_CLASS_USER_INITIATED
*-DISPATCH_QUEUE_PRIORITY_DEFAULT：QOS_CLASS_DEFAULT
*-DISPATCH_QUEUE_PRIORITY_LOW：QOS_CLASS\u实用程序
*-DISPATCH_QUEUE_PRIORITY_BACKGROUND：QOS_CLASS_BACKGROUND
*示例：
*<代码>
*dispatch_queue_t queue；
*dispatch_queue_attr_t attr；
*attr=dispatch_queue_attr_make_with_qos_class（dispatch_queue_SERIAL，
*QOS_CLASS\u实用程序，0）；
*queue=dispatch_queue_create（“com.example.myqueue”，attr）；
*</代码>
*以这种方式在队列上设置的QOS类和相对优先级对
*同步提交到队列的块（通过dispatch_sync()，
*dispatch_barrier_sync()）。
*@参数属性
*要与QOS类组合的队列属性值，或NULL。
*@参数qos\u类
*QOS类值：
*-QOS_CLASS_USER_INTERACTIVE
*-QOS_CLASS_USER\u已启动
*-QOS_CLASS\u默认值
*-QOS_CLASS\u实用程序
*-QOS_CLASS\u后台
*传递任何其他值都会导致返回NULL。
*@参数相对优先级
*QOS类中的相对优先级。此值为负值
*给定类支持的最大调度程序优先级的偏移量。
*传递大于零或小于QOS_MIN_RELATIVE_PRIORITY的值
*结果返回NULL。
*@返回
*返回可提供给dispatch_queue_create()的属性值
*和dispatch_queue_create_with_target()，如果使用了无效的QOS类，则为NULL
*已请求。
*新值将“attr”参数指定的属性与
*新的QOS类别和相对优先级。
*/
API_AVAILABLE(macos(10.10), ios(8.0))
DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_PURE DISPATCH_NOTHROW
dispatch_queue_attr_t
dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t_Nullableattr,
dispatch_qos_class_t qos_class,intrelative_priority);
/*!
*@const DISPATCH_TARGET_QUEUE_DEFAULT
*@要传递给dispatch_queue_create_with_target()的讨论常量，
*dispatch_set_target_queue()和dispatch_source_create()函数
*指示相关对象类型的默认目标队列
*应使用。
*/
#define DISPATCH_TARGET_QUEUE_DEFAULT NULL
/*!
*@函数dispatch_queue_create_with_target
*@摘要
*使用指定的目标队列创建新的调度队列。
*@讨论
*使用Dispatch_QUEUE_SERIAL或NULL属性创建的调度队列
*按FIFO顺序串行调用块。
*使用Dispatch_QUEUE_CONCURRENT属性创建的调度队列可能
*并发调用块（类似于全局并发队列，但
*可能会有更多开销），并支持提交的屏障块
*dispatch barrier API，可实现高效的
*读写器方案。
*当不再需要调度队列时，应使用
*dispatch_release()。请注意，任何以异步方式提交到的挂起块
*队列将包含对该队列的引用。因此，队列不会
*解除分配，直到所有挂起的块完成。
*使用调度队列属性@属性指定QoS类时（派生
*根据dispatch_queue_attr_make_with_qos_class()）的结果，传递
*@a target中dispatch_get_global_queue()的结果将忽略QoS类
*并将使用具有QoS类的全局队列
*由attr指定。
*使用dispatch_queue_create_with_target()创建的队列不能具有
*目标队列已更改，除非创建为非活动队列（请参阅
*dispatch_queue_attr_make_initially_inactive()），在这种情况下，目标
*可以更改队列，直到用激活新创建的队列
*dispatch_activate()。
*@参数标签
*要附加到队列的字符串标签。
*此参数是可选的，可以为NULL。
*@参数属性
*预定义属性，如DISPATCH_QUEUE_SERIAL，
*DISPATCH_QUEUE_CONCURRENT，或调用的结果
*一个dispatch_queue_attr_make\u，带有\*函数。
*@参数目标
*新创建队列的目标队列。将保留目标队列。
*如果此参数为DISPATCH_TARGET_QUEUE_DEFAULT，则设置队列的目标
*队列到给定队列类型的默认目标队列。
*@结果
*新创建的调度队列。
*/
API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
DISPATCH_NOTHROW
dispatch_queue_t
dispatch_queue_create_with_target(constchar*_Nullablelabel,
dispatch_queue_attr_t_Nullableattr, dispatch_queue_t_Nullabletarget)
DISPATCH_ALIAS_V2(dispatch_queue_create_with_target);
/*!
*@函数dispatch_queue_create
*@摘要
*创建一个新的调度队列，可以将块提交到该队列。
*@讨论
*使用Dispatch_QUEUE_SERIAL或NULL属性创建的调度队列
*按FIFO顺序串行调用块。
*使用Dispatch_QUEUE_CONCURRENT属性创建的调度队列可能
*并发调用块（类似于全局并发队列，但
*可能会有更多开销），并支持提交的屏障块
*dispatch barrier API，可实现高效的
*读写器方案。
*当不再需要调度队列时，应使用
*dispatch_release()。请注意，任何以异步方式提交到的挂起块
*队列将包含对该队列的引用。因此，队列不会
*解除分配，直到所有挂起的块完成。
*使用_qos_class()函数传递dispatch_queue_attr_make\u的结果
*此函数的attr参数允许服务质量类和
*要为新创建的队列指定的相对优先级。
*规定的服务质量等级优先于质量等级
*新创建的调度队列的目标队列的服务类（如果有）
*只要这不会导致较低的QOS级别和相对优先级。
*如果未指定服务质量类，则
*创建的调度队列是默认优先级全局并发队列。
*@参数标签
*要附加到队列的字符串标签。
*此参数是可选的，可以为NULL。
*@参数属性
*预定义属性，如DISPATCH_QUEUE_SERIAL，
*DISPATCH_QUEUE_CONCURRENT，或调用的结果
*一个dispatch_queue_attr_make\u，带有\*函数。
*@结果
*新创建的调度队列。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_MALLOC DISPATCH_RETURNS_RETAINED DISPATCH_WARN_RESULT
DISPATCH_NOTHROW
dispatch_queue_t
dispatch_queue_create(constchar*_Nullablelabel,
dispatch_queue_attr_t_Nullableattr);
/*!
*@const DISPATCH_CURRENT_QUEUE\u标签
*@要传递给dispatch_queue_get_label()函数的讨论常量
*检索当前队列的标签。
*/
#define DISPATCH_CURRENT_QUEUE_LABEL NULL
/*!
*@函数dispatch_queue_get_label
*@摘要
*返回给定队列的标签，如创建队列时指定的
*如果指定了空标签，则为空字符串。
*传递DISPATCH_CURRENT_QUEUE_LABEL将返回当前
*队列。
*@参数队列
*要查询的队列，或DISPATCH_CURRENT_queue\u标签。
*@结果
*队列的标签。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
constchardispatch_queue_get_label(dispatch_queue_t_Nullablequeue);
/*!
*@函数dispatch_queue_get_qos\u类
*@摘要
*返回给定队列的QOS类和相对优先级。
*@讨论
*如果给定队列是使用返回的属性值创建的
*dispatch_queue_attr_make_with_qos_class()，此函数返回qos
*当时规定的等级和相对优先级；对于任何其他属性
*值它返回一个QOS_class\u未指定的QOS类和一个相对
*优先级为0。
*如果给定队列是全局队列之一，则此函数将返回其
*根据dispatch_get_global_queue()和
*相对优先级为0；对于主队列，它返回QOS
*qos_class_main()提供的值，相对优先级为0。
*@参数队列
*要查询的队列。
*@参数relative_priority_ptr
*指向要用相对优先级偏移量填充的int变量的指针
*在QOS类中，或为NULL。
*@返回
*QOS类值：
*-QOS_CLASS_USER_INTERACTIVE
*-QOS_CLASS_USER\u已启动
*-QOS_CLASS\u默认值
*-QOS_CLASS\u实用程序
*-QOS_CLASS\u后台
*-QOS_CLASS\u未指定
*/
API_AVAILABLE(macos(10.10), ios(8.0))
DISPATCH_EXPORT DISPATCH_WARN_RESULT DISPATCH_NONNULL1 DISPATCH_NOTHROW
dispatch_qos_class_t
dispatch_queue_get_qos_class(dispatch_queue_t queue,
int*_Nullablerelative_priority_ptr);
/*!
*@函数dispatch_set_target_queue
*@摘要
*设置给定对象的目标队列。
*@讨论
*对象的目标队列负责处理该对象。
*当没有为指定服务质量等级和相对优先级时
*调度队列创建时，调度队列的服务质量
*类从其目标队列继承。dispatch_get_global_queue()
*函数可用于获取特定质量的目标队列
*服务类，但是使用dispatch_queue_attr_make_with_qos_class()
*建议改为。
*提交到目标队列为另一个串行队列的串行队列的块
*队列不会与提交给目标的块同时调用
*队列或具有相同目标队列的任何其他队列。
*将循环引入目标队列层次结构的结果是
*未定义。
*调度源的目标队列指定其事件处理程序和
*将提交取消处理程序块。
*调度I/O通道的目标队列指定其I/O的位置
*执行操作。如果通道的目标队列的优先级设置为
*DISPATCH_QUEUE_PRIORITY_BACKGROUND，然后由执行的I/O操作
*该队列上的dispatch_io_read()或dispatch_io_write()将
*存在I/O争用时已阻止。
*对于所有其他调度对象类型，目标队列的唯一功能
*用于确定在何处调用对象的终结器函数。
*通常，更改对象的目标队列是异步的
*不会立即生效且不会影响块的操作
*已与指定对象关联。
*但是，如果在dispatch_set_target_queue()为
*调用，则目标队列更改立即生效，并将
*影响已与指定对象关联的块。在
*初始非活动对象已激活，调用
*dispatch_set_target_queue()导致一个断言，进程
*终止。
*如果调度队列处于活动状态，并且是其他调度对象的目标，
*更改其目标队列会导致未定义的行为。
*@参数对象
*要修改的对象。
*此参数中传递NULL的结果未定义。
*@参数队列
*对象的新目标队列。队列将保留，并且
*释放上一个目标队列（如果有）。
*如果queue是DISPATCH_TARGET_queue_DEFAULT，则设置对象的目标队列
*到给定对象类型的默认目标队列。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NOTHROW
void
dispatch_set_target_queue(dispatch_object_t object,
dispatch_queue_t_Nullablequeue);
/*!
*函数 dispatch_main
*@摘要
*执行提交到主队列的块。
*@讨论
*此函数“停止”主线程并等待提交块
*到主队列。此函数永远不会返回。
*在上调用NSApplicationMain()或CFRunLoopRun()的应用程序
*主线程不需要调用dispatch_main()。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NOTHROW DISPATCH_NORETURN
void
dispatch_main(void);
/*!
*函数 dispatch_after
*@摘要
*计划在指定时间在给定队列上执行块。
*@讨论
*支持将DISPATCH_TIME_NOW作为“when”参数传递，但不作为
*改为调用dispatch_async()是最佳的。永远通过DISPATCH_TIME\u
*未定义。
*@参数何时
*dispatch_time()或dispatch_walltime()返回的时间里程碑。
*@参数队列
*给定块将在指定时间提交到的队列。
*此参数中传递NULL的结果未定义。
*@参数块
*要执行的代码块。
*此参数中传递NULL的结果未定义。
*/
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_after(dispatch_time_t when, dispatch_queue_t queue,
dispatch_block_t block);
#endif
/*!
*函数 dispatch_after_f
*@摘要
*安排函数在指定时间在给定队列上执行。
*@讨论
*有关详细信息，请参阅dispatch_after()。
*@参数何时
*dispatch_time()或dispatch_walltime()返回的时间里程碑。
*@参数队列
*给定函数将在指定时间提交到的队列。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_after_f().。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.6), ios(4.0))
DISPATCH_EXPORT DISPATCH_NONNULL2 DISPATCH_NONNULL4 DISPATCH_NOTHROW
void
dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue,
void*_Nullablecontext, dispatch_function_t work);
/*!
*函数group Dispatch Barrier API
*dispatch barrier API是一种将屏障块提交给
*调度队列，类似于dispatch_async()/dispatch_sync()API。
*它可以实现高效的读写器方案。
*屏障块仅在提交到使用
*DISPATCH_QUEUE_CONCURRENT属性；在这样的队列上，障碍块
*在之前提交到队列的所有块完成之前，不会运行，
*并且在屏障块之后提交到队列的任何块都不会运行
*直到隔离块完成。
*提交到全局队列或未使用创建的队列时
*DISPATCH_QUEUE_CONCURRENT属性，屏障块的行为与
*使用dispatch_async()/dispatch_sync()API提交的块。
*/
/*!
*函数 dispatch_barrier_async
*@摘要
*提交屏障块以在调度队列上异步执行。
*@讨论
*将块提交到dispatch_async()之类的调度队列，但标记为
*阻止为屏障（仅与DISPATCH_QUEUE\u并发队列相关）。
*有关详细信息，请参阅dispatch_async()，有关说明，请参阅“dispatch Barrier API”
*障碍语义。
*@参数队列
*将块提交到的目标调度队列。
*系统将在目标队列上保留引用，直到阻塞
*已完成。
*此参数中传递NULL的结果未定义。
*@参数块
*要提交到目标调度队列的块。此函数执行
*代表调用方执行Block_copy()和Block_release()。
*此参数中传递NULL的结果未定义。
*/
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.7), ios(4.3))
DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
void
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
#endif
/*!
*函数 dispatch_barrier_async_f
*@摘要
*提交barrier函数以在调度队列上异步执行。
*@讨论
*将函数提交到调度队列，如dispatch_async_f()，但标记
*作为屏障的功能（仅在DISPATCH_QUEUE_CONCURRENT上相关
*队列）。
*有关详细信息，请参阅dispatch_async_f()，有关
*障碍语义的描述。
*@参数队列
*将函数提交到的目标调度队列。
*系统将在目标队列上保留引用，直到函数
*已返回。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_barrier_async_f()。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.7), ios(4.3))
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_barrier_async_f(dispatch_queue_t queue,
void*_Nullablecontext, dispatch_function_t work);
/*!
*函数 dispatch_barrier_sync
*@摘要
*提交屏障块以在调度队列上同步执行。
*@讨论
*将块提交到dispatch_sync()之类的调度队列，但标记为
*阻止为屏障（仅与DISPATCH_QUEUE\u并发队列相关）。
*有关详细信息，请参阅dispatch_sync()，有关说明，请参阅“dispatch Barrier API”
*障碍语义。
*@参数队列
*将块提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数块
*要在目标调度队列上调用的块。
*此参数中传递NULL的结果未定义。
*/
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.7), ios(4.3))
DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
void
dispatch_barrier_sync(dispatch_queue_t queue,
DISPATCH_NOESCAPE dispatch_block_t block);
#endif
/*!
*函数 dispatch_barrier_sync_f
*@摘要
*提交屏障函数，以便在调度队列上同步执行。
*@讨论
*将函数提交到dispatch_sync_f()之类的调度队列，但标记为
*作为屏障的功能（仅与DISPATCH_QUEUE\u并发队列相关）。
*有关详细信息，请参阅dispatch_sync_f()。
*@参数队列
*将函数提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_barrier_sync_f()。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.7), ios(4.3))
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_barrier_sync_f(dispatch_queue_t queue,
void*_Nullablecontext, dispatch_function_t work);
/*!
*函数 dispatch_barrier_async_and_wait
*@摘要
*提交块以在调度队列上同步执行。
*@讨论
*将块提交到dispatch_async\u和_wait()等调度队列，但标记
*该块作为屏障（仅与DISPATCH_QUEUE_CONCURRENT相关
*队列）。
*有关屏障语义的描述，请参阅“Dispatch Barrier API”。
*@参数队列
*将块提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数工时
*要在目标队列上调用的应用程序定义的块。
*此参数中传递NULL的结果未定义。
*/
#ifdef __BLOCKS__
API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
DISPATCH_EXPORT DISPATCH_NONNULL_ALL DISPATCH_NOTHROW
void
dispatch_barrier_async_and_wait(dispatch_queue_t queue,
DISPATCH_NOESCAPE dispatch_block_t block);
#endif
/*!
*函数 dispatch_barrier_async_and_wait_f
*@摘要
*提交用于在调度队列上同步执行的函数。
*@讨论
*将函数提交到调度队列，如dispatch_async\u和_wait_f()，但
*将其标记为屏障仅与dispatch_async_and_wait_f(), but
* marks that function as a barrier (relevant only on DISPATCH_QUEUE_CONCURRENT
* queues).
*有关屏障语义的描述，请参阅“Dispatch Barrier API”。
*@参数队列
*将函数提交到的目标调度队列。
*此参数中传递NULL的结果未定义。
*@参数上下文
*要传递给函数的应用程序定义的上下文参数。
*@参数工时
*要在目标队列上调用的应用程序定义的函数。第一个
*传递给此函数的参数是提供给的上下文
*dispatch_barrier_async_and_wait_f()。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.14), ios(12.0), tvos(12.0), watchos(5.0))
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NONNULL3 DISPATCH_NOTHROW
void
dispatch_barrier_async_and_wait_f(dispatch_queue_t queue,
void*_Nullablecontext, dispatch_function_t work);
/*!
*@功能 组Dispatch queue-specific contexts
*此API允许不同的子系统将上下文关联到共享队列
*无冲突风险，并从执行的块中检索上下文
*在目标队列层次结构中的该队列或其任何子队列上。
*/
/*!
*函数 dispatch_queue_set_specific
*@摘要
*将子系统特定上下文与密钥的调度队列相关联
*子系统独有。
*@讨论
*指定的析构函数将在默认
*优先级全局并发队列为同一密钥设置新上下文时，
*或者在释放对队列的所有引用之后。
*@参数队列
*要修改的调度队列。
*此参数中传递NULL的结果未定义。
*@参数键
*设置上下文的键，通常是指向静态变量的指针
*特定于子系统。键仅作为指针进行比较，从不进行比较
*取消引用。不建议直接传递字符串常量。
*空键是保留的，为其设置上下文的尝试将被忽略。
*@参数上下文
*对象的新子系统特定上下文。这可能为空。
*@参数析构函数
*析构函数指针。这可能为NULL，如果上下文
*为空。
*/
API_AVAILABLE(macos(10.7), ios(5.0))
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_NOTHROW
void
dispatch_queue_set_specific(dispatch_queue_t queue,constvoid*key,
void*_Nullablecontext, dispatch_function_t_Nullabledestructor);
/*!
*函数 dispatch_queue_get_specific
*@摘要
*返回与调度队列关联的子系统特定上下文，用于
*子系统特有的密钥。
*@讨论
*如果指定键已在指定的
*队列。
*@参数队列
*要查询的调度队列。
*此参数中传递NULL的结果未定义。
*@参数键
*获取上下文的键，通常是指向静态变量的指针
*特定于子系统。键仅作为指针进行比较，从不进行比较
*取消引用。不建议直接传递字符串常量。
*@结果
*指定键的上下文，如果找不到上下文，则为NULL。
*/
API_AVAILABLE(macos(10.7), ios(5.0))
DISPATCH_EXPORT DISPATCH_NONNULL1 DISPATCH_PURE DISPATCH_WARN_RESULT
DISPATCH_NOTHROW
void*_Nullable
dispatch_queue_get_specific(dispatch_queue_t queue,constvoid*key);
/*!
*函数 dispatch_get_specific
*@摘要
*返回的唯一键的当前子系统特定上下文
*子系统。
*@讨论
*从队列上执行的块调用时，返回
*如果已在队列上设置了指定键，则返回结果
*在队列的目标队列上执行的dispatch_get_specific()的个数或NULL
*如果当前队列是全局并发队列。
*@参数键
*获取上下文的键，通常是指向静态变量的指针
*特定于子系统。键仅作为指针进行比较，从不进行比较
*取消引用。不建议直接传递字符串常量。
*@结果
*指定键的上下文，如果找不到上下文，则为NULL。
*/
API_AVAILABLE(macos(10.7), ios(5.0))
DISPATCH_EXPORT DISPATCH_PURE DISPATCH_WARN_RESULT DISPATCH_NOTHROW
void*_Nullable
dispatch_get_specific(constvoid*key);
/*!
*函数group Dispatch assertion API
*此API在运行时断言代码正在上下文中（或在上下文外）执行
*给定队列的。它可用于检查访问资源的块
*从保护资源的适当队列执行此操作。也可以使用
*验证在给定队列上运行时可能导致死锁的块
*从不在该队列上执行。
*/
/*!
*函数 dispatch_assert_queue
*@摘要
*验证当前块是否正在给定调度队列上执行。
*@讨论
*某些代码需要在特定的调度队列上运行。此函数
*验证该期望是否为真。
*如果当前执行的块已提交到指定队列或
*任何以其为目标的队列（请参阅dispatch_set_target_queue()），此函数
*返回。
*如果当前执行的块是使用同步API提交的
*（dispatch_sync()，dispatch_barrier_sync()，…），的上下文
*还将计算提交块（递归）。
*如果发现同步提交块本身已提交到
*此函数返回指定的队列或指向该队列的任何队列。
*否则，此函数断言：它将向系统日志记录解释，并
*终止应用程序。
*将dispatch_get_main_queue()的结果传递到此函数可验证
*当前块已提交到主队列或队列
*以它为目标，或在主线程上运行（在任何上下文中）。
*在
*提交的块（例如，来自手动创建的线程的上下文
*使用pthread_create()），则此函数也将断言和终止
*应用程序。
*变量dispatch_assert_queue_debug()在
*定义了预处理器宏NDEBUG。（另见断言（3））。
*@参数队列
*当前块预期在其上运行的调度队列。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
DISPATCH_EXPORT DISPATCH_NONNULL1
void
dispatch_assert_queue(dispatch_queue_t queue)
DISPATCH_ALIAS_V2(dispatch_assert_queue);
/*!
*函数 dispatch_assert_queue_barrier
*@摘要
*验证当前块是否正在给定调度队列上执行，
*并且该块在该队列上充当屏障。
*@讨论
*这与dispatch_assert_queue()的行为完全相同，并进行了额外的检查
*当前块在指定队列上充当屏障，即
*如果指定队列为串行队列，则始终为true（请参阅DISPATCH_BLOCK_BARRIER或
*dispatch_barrier_async()获取详细信息）。
*变量dispatch_assert_queue_barrier_debug()在
*定义了预处理器宏NDEBUG。（另请参见assert()）。
*@参数队列
*当前块预期作为屏障运行的调度队列。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
DISPATCH_EXPORT DISPATCH_NONNULL1
void
dispatch_assert_queue_barrier(dispatch_queue_t queue);
/*!
*函数 dispatch_assert_queue_not
*@摘要
*验证当前块是否未在给定的调度队列上执行。
*@讨论
*此函数等效于dispatch_assert_queue()，用于测试
*相等反转。这意味着它将在以下情况下终止应用程序
*dispatch_assert_queue()将返回，反之亦然。请参见此处的讨论。
*变量dispatch_assert_queue_not_debug()在
*定义了预处理器宏NDEBUG。（另见断言（3））。
*@参数队列
*当前块预期不会在其上运行的调度队列。
*此参数中传递NULL的结果未定义。
*/
API_AVAILABLE(macos(10.12), ios(10.0), tvos(10.0), watchos(3.0))
DISPATCH_EXPORT DISPATCH_NONNULL1
void
dispatch_assert_queue_not(dispatch_queue_t queue)
DISPATCH_ALIAS_V2(dispatch_assert_queue_not);
#ifdef NDEBUG
#define dispatch_assert_queue_debug(q) ((void)(0 && (q)))
#define dispatch_assert_queue_barrier_debug(q) ((void)(0 && (q)))
#define dispatch_assert_queue_not_debug(q) ((void)(0 && (q)))
#else
#define dispatch_assert_queue_debug(q) dispatch_assert_queue(q)
#define dispatch_assert_queue_barrier_debug(q) dispatch_assert_queue_barrier(q)
#define dispatch_assert_queue_not_debug(q) dispatch_assert_queue_not(q)
#endif
__END_DECLS
DISPATCH_ASSUME_NONNULL_END
#endif
