上一篇 《iOS底层探索 -- 多线程》 介绍了多线程的一些东西以及对
GCD进行了初探，分析了GCD的一些常见面试题，这一篇来探索一下GCD的底层实现。
1. GCD 队列的创建
GCD的队列创建，我们都很熟悉，通常用下面的方式：
// 并发
dispatch_queue_t queue1 = dispatch_queue_create("DDD", DISPATCH_QUEUE_CONCURRENT);
// 串行
dispatch_queue_t queue2 = dispatch_queue_create("LLL", NULL);
我们对两个队列进行po，结果如下：
然后，通过一系列手段（汇编），最终定位到
GCD源码，在libdispatch源码中。
在通过dispatch_queue_create()方法创建队列时，底层会统一调用中间层方法_dispatch_lane_create_with_target()：
dispatch_queue_t
dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)
{
return _dispatch_lane_create_with_target(label, attr,
DISPATCH_TARGET_QUEUE_DEFAULT, true);
}
在_dispatch_lane_create_with_target()方法中：
- 第一个参数：是字符串标签
- 第二个参数：是预定义属性，如
DISPATCH_QUEUE_SERIAL，DISPATCH_QUEUE_CONCURRENT
第二个参数就是我们创建队列时传进来的，决定了队列是串行队列还是并发队列。
那么在
_dispatch_lane_create_with_target()中，是怎么通过参数决定是并发/串行队列呢？队列又是怎么创建的呢？接下来，我们分析一下这个方法。
并发/串行队列底层探索
首先，看下面部分源码:
先通过传进来的预定义属性dqa，通过_dispatch_queue_attr_to_info()方法，构建一个dispatch_queue_attr_info_t类型的dqai。
dispatch_queue_attr_info_t是一个结构体，里面有一系列的属性，如下：
typedef struct dispatch_queue_attr_info_s {
dispatch_qos_t dqai_qos : 8;
int dqai_relpri : 8;
uint16_t dqai_overcommit:2;
uint16_t dqai_autorelease_frequency:2;
uint16_t dqai_concurrent:1;
uint16_t dqai_inactive:1;
} dispatch_queue_attr_info_t;
_dispatch_queue_attr_to_info()方法源码如下：
dispatch_queue_attr_info_t
_dispatch_queue_attr_to_info(dispatch_queue_attr_t dqa)
{
dispatch_queue_attr_info_t dqai = { };
if (!dqa) return dqai;
#if DISPATCH_VARIANT_STATIC
if (dqa == &_dispatch_queue_attr_concurrent) {
dqai.dqai_concurrent = true;
return dqai;
}
#endif
if (dqa < _dispatch_queue_attrs ||
dqa >= &_dispatch_queue_attrs[DISPATCH_QUEUE_ATTR_COUNT]) {
DISPATCH_CLIENT_CRASH(dqa->do_vtable, "Invalid queue attribute");
}
// 苹果的算法
size_t idx = (size_t)(dqa - _dispatch_queue_attrs);
// 位域
// 0000 000000000 00000000000 0000 000 1
dqai.dqai_inactive = (idx % DISPATCH_QUEUE_ATTR_INACTIVE_COUNT);
idx /= DISPATCH_QUEUE_ATTR_INACTIVE_COUNT;
dqai.dqai_concurrent = !(idx % DISPATCH_QUEUE_ATTR_CONCURRENCY_COUNT);
idx /= DISPATCH_QUEUE_ATTR_CONCURRENCY_COUNT;
dqai.dqai_relpri = -(idx % DISPATCH_QUEUE_ATTR_PRIO_COUNT);
idx /= DISPATCH_QUEUE_ATTR_PRIO_COUNT;
dqai.dqai_qos = idx % DISPATCH_QUEUE_ATTR_QOS_COUNT;
idx /= DISPATCH_QUEUE_ATTR_QOS_COUNT;
dqai.dqai_autorelease_frequency =
idx % DISPATCH_QUEUE_ATTR_AUTORELEASE_FREQUENCY_COUNT;
idx /= DISPATCH_QUEUE_ATTR_AUTORELEASE_FREQUENCY_COUNT;
dqai.dqai_overcommit = idx % DISPATCH_QUEUE_ATTR_OVERCOMMIT_COUNT;
idx /= DISPATCH_QUEUE_ATTR_OVERCOMMIT_COUNT;
return dqai;
}
构建dqai时：
- 先创建一个空的
dispatch_queue_attr_info_tdqai - 判断
dqa是否为空，为空直接，返回 - 不为空，则对
dqai中的属性进行操作赋值，
#define DISPATCH_QUEUE_SERIAL NULL
#define DISPATCH_QUEUE_CONCURRENT \
DISPATCH_GLOBAL_OBJECT(dispatch_queue_attr_t, \
_dispatch_queue_attr_concurrent)
串行队列传入的dqa即：DISPATCH_QUEUE_SERIAL，为NULL，直接返回。并没有对daqi中的其他属性进行操作。
而并发队列中传入的dqa即：DISPATCH_QUEUE_CONCURRENT，不为NULL，所以会对dqai中的其他属性进行位域操作赋值。
在dqai构建构建完成后，开始规范化参数(qos、overcommit、tq)
规范化参数的源码如下：
//
// Step 1: Normalize arguments (qos, overcommit, tq)
//
// ✅ qos
dispatch_qos_t qos = dqai.dqai_qos;
#if !HAVE_PTHREAD_WORKQUEUE_QOS
if (qos == DISPATCH_QOS_USER_INTERACTIVE) {
dqai.dqai_qos = qos = DISPATCH_QOS_USER_INITIATED;
}
if (qos == DISPATCH_QOS_MAINTENANCE) {
dqai.dqai_qos = qos = DISPATCH_QOS_BACKGROUND;
}
#endif // !HAVE_PTHREAD_WORKQUEUE_QOS
// ✅ 设置overcommit，串行队列有overcommit，
_dispatch_queue_attr_overcommit_t overcommit = dqai.dqai_overcommit;
if (overcommit != _dispatch_queue_attr_overcommit_unspecified && tq) {
if (tq->do_targetq) {
DISPATCH_CLIENT_CRASH(tq, "Cannot specify both overcommit and "
"a non-global target queue");
}
}
if (tq && dx_type(tq) == DISPATCH_QUEUE_GLOBAL_ROOT_TYPE) {
// Handle discrepancies between attr and target queue, attributes win
if (overcommit == _dispatch_queue_attr_overcommit_unspecified) {
if (tq->dq_priority & DISPATCH_PRIORITY_FLAG_OVERCOMMIT) {
overcommit = _dispatch_queue_attr_overcommit_enabled;
} else {
overcommit = _dispatch_queue_attr_overcommit_disabled;
}
}
if (qos == DISPATCH_QOS_UNSPECIFIED) {
qos = _dispatch_priority_qos(tq->dq_priority);
}
tq = NULL;
} else if (tq && !tq->do_targetq) {
// target is a pthread or runloop root queue, setting QoS or overcommit
// is disallowed
if (overcommit != _dispatch_queue_attr_overcommit_unspecified) {
DISPATCH_CLIENT_CRASH(tq, "Cannot specify an overcommit attribute "
"and use this kind of target queue");
}
} else {
if (overcommit == _dispatch_queue_attr_overcommit_unspecified) {
// Serial queues default to overcommit!
// ✅ 串行队列默认过度提交!
overcommit = dqai.dqai_concurrent ?
_dispatch_queue_attr_overcommit_disabled :
_dispatch_queue_attr_overcommit_enabled;
}
}
// ✅ 根据qos 从root_queue中获取一个队列
if (!tq) {
tq = _dispatch_get_root_queue(
qos == DISPATCH_QOS_UNSPECIFIED ? DISPATCH_QOS_DEFAULT : qos, // 4
overcommit == _dispatch_queue_attr_overcommit_enabled)->_as_dq; // 0 1
if (unlikely(!tq)) {
DISPATCH_CLIENT_CRASH(qos, "Invalid queue attribute");
}
}
在根据qos 从root_queue中获取队列时，调用_dispatch_get_root_queue（）方法：
_dispatch_get_root_queue(dispatch_qos_t qos, bool overcommit)
{
if (unlikely(qos < DISPATCH_QOS_MIN || qos > DISPATCH_QOS_MAX)) {
DISPATCH_CLIENT_CRASH(qos, "Corrupted priority");
}
// 4-1= 3
// 2*3+0/1 = 6/7
return &_dispatch_root_queues[2 * (qos - 1) + overcommit];
}
根据传进来的qos和overcommit，进行计算，最终为6或者7，然后从_dispatch_root_queues[]中取出对应下标的队列，_dispatch_root_queues[]如下：
struct dispatch_queue_global_s _dispatch_root_queues[] = {
#define _DISPATCH_ROOT_QUEUE_IDX(n, flags) \
((flags & DISPATCH_PRIORITY_FLAG_OVERCOMMIT) ? \
DISPATCH_ROOT_QUEUE_IDX_##n##_QOS_OVERCOMMIT : \
DISPATCH_ROOT_QUEUE_IDX_##n##_QOS)
#define _DISPATCH_ROOT_QUEUE_ENTRY(n, flags, ...) \
[_DISPATCH_ROOT_QUEUE_IDX(n, flags)] = { \
DISPATCH_GLOBAL_OBJECT_HEADER(queue_global), \
.dq_state = DISPATCH_ROOT_QUEUE_STATE_INIT_VALUE, \
.do_ctxt = _dispatch_root_queue_ctxt(_DISPATCH_ROOT_QUEUE_IDX(n, flags)), \
.dq_atomic_flags = DQF_WIDTH(DISPATCH_QUEUE_WIDTH_POOL), \
.dq_priority = flags | ((flags & DISPATCH_PRIORITY_FLAG_FALLBACK) ? \
_dispatch_priority_make_fallback(DISPATCH_QOS_##n) : \
_dispatch_priority_make(DISPATCH_QOS_##n, 0)), \
__VA_ARGS__ \
}
_DISPATCH_ROOT_QUEUE_ENTRY(MAINTENANCE, 0,
.dq_label = "com.apple.root.maintenance-qos",
.dq_serialnum = 4,
),
_DISPATCH_ROOT_QUEUE_ENTRY(MAINTENANCE, DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
.dq_label = "com.apple.root.maintenance-qos.overcommit",
.dq_serialnum = 5,
),
_DISPATCH_ROOT_QUEUE_ENTRY(BACKGROUND, 0,
.dq_label = "com.apple.root.background-qos",
.dq_serialnum = 6,
),
_DISPATCH_ROOT_QUEUE_ENTRY(BACKGROUND, DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
.dq_label = "com.apple.root.background-qos.overcommit",
.dq_serialnum = 7,
),
_DISPATCH_ROOT_QUEUE_ENTRY(UTILITY, 0,
.dq_label = "com.apple.root.utility-qos",
.dq_serialnum = 8,
),
_DISPATCH_ROOT_QUEUE_ENTRY(UTILITY, DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
.dq_label = "com.apple.root.utility-qos.overcommit",
.dq_serialnum = 9,
),
_DISPATCH_ROOT_QUEUE_ENTRY(DEFAULT, DISPATCH_PRIORITY_FLAG_FALLBACK,
.dq_label = "com.apple.root.default-qos",
.dq_serialnum = 10,
),
_DISPATCH_ROOT_QUEUE_ENTRY(DEFAULT,
DISPATCH_PRIORITY_FLAG_FALLBACK | DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
.dq_label = "com.apple.root.default-qos.overcommit",
.dq_serialnum = 11,
),
_DISPATCH_ROOT_QUEUE_ENTRY(USER_INITIATED, 0,
.dq_label = "com.apple.root.user-initiated-qos",
.dq_serialnum = 12,
),
_DISPATCH_ROOT_QUEUE_ENTRY(USER_INITIATED, DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
.dq_label = "com.apple.root.user-initiated-qos.overcommit",
.dq_serialnum = 13,
),
_DISPATCH_ROOT_QUEUE_ENTRY(USER_INTERACTIVE, 0,
.dq_label = "com.apple.root.user-interactive-qos",
.dq_serialnum = 14,
),
_DISPATCH_ROOT_QUEUE_ENTRY(USER_INTERACTIVE, DISPATCH_PRIORITY_FLAG_OVERCOMMIT,
.dq_label = "com.apple.root.user-interactive-qos.overcommit",
.dq_serialnum = 15,
),
};
最终取出第6或者第7个队列，其dq_label和po串行队列和并发队列时，打印的target一致。
然后开始初始化队列。
初始化队列
//
// Step 2: Initialize the queue
//
if (legacy) {
// if any of these attributes is specified, use non legacy classes
if (dqai.dqai_inactive || dqai.dqai_autorelease_frequency) {
legacy = false;
}
}
const void *vtable;
dispatch_queue_flags_t dqf = legacy ? DQF_MUTABLE : 0;
if (dqai.dqai_concurrent) {
// ✅ 通过dqai.dqai_concurrent 来区分并发和串行
// OS_dispatch_queue_concurrent_class
vtable = DISPATCH_VTABLE(queue_concurrent);
} else {
// OS_dispatch_queue_serial_class
vtable = DISPATCH_VTABLE(queue_serial);
}
switch (dqai.dqai_autorelease_frequency) {
case DISPATCH_AUTORELEASE_FREQUENCY_NEVER:
dqf |= DQF_AUTORELEASE_NEVER;
break;
case DISPATCH_AUTORELEASE_FREQUENCY_WORK_ITEM:
dqf |= DQF_AUTORELEASE_ALWAYS;
break;
}
if (label) {
const char *tmp = _dispatch_strdup_if_mutable(label);
if (tmp != label) {
dqf |= DQF_LABEL_NEEDS_FREE;
label = tmp;
}
}
// ✅ 开辟内存 - 生成响应的对象 queue
dispatch_lane_t dq = _dispatch_object_alloc(vtable,
sizeof(struct dispatch_lane_s));
// ✅ 构造方法
_dispatch_queue_init(dq, dqf, dqai.dqai_concurrent ?
DISPATCH_QUEUE_WIDTH_MAX : 1, DISPATCH_QUEUE_ROLE_INNER |
(dqai.dqai_inactive ? DISPATCH_QUEUE_INACTIVE : 0));
// ✅ 标签
dq->dq_label = label;
// ✅ 优先级
dq->dq_priority = _dispatch_priority_make((dispatch_qos_t)dqai.dqai_qos,
dqai.dqai_relpri);
if (overcommit == _dispatch_queue_attr_overcommit_enabled) {
dq->dq_priority |= DISPATCH_PRIORITY_FLAG_OVERCOMMIT;
}
if (!dqai.dqai_inactive) {
_dispatch_queue_priority_inherit_from_target(dq, tq);
_dispatch_lane_inherit_wlh_from_target(dq, tq);
}
_dispatch_retain(tq);
dq->do_targetq = tq;
在初始化队列时：
- 通过
dqai.dqai_concurrent来区分并发和串行，来创建一个vtable， - 然后开辟空间
_dispatch_object_alloc() - 调用构造方法，初始化队列
- 设置标签，优先级，
target等
在调用_dispatch_queue_init()初始化队列时，源码如下：
static inline dispatch_queue_class_t
_dispatch_queue_init(dispatch_queue_class_t dqu, dispatch_queue_flags_t dqf,
uint16_t width, uint64_t initial_state_bits)
{
uint64_t dq_state = DISPATCH_QUEUE_STATE_INIT_VALUE(width);
dispatch_queue_t dq = dqu._dq;
dispatch_assert((initial_state_bits & ~(DISPATCH_QUEUE_ROLE_MASK |
DISPATCH_QUEUE_INACTIVE)) == 0);
if (initial_state_bits & DISPATCH_QUEUE_INACTIVE) {
dq_state |= DISPATCH_QUEUE_INACTIVE + DISPATCH_QUEUE_NEEDS_ACTIVATION;
dq->do_ref_cnt += 2; // rdar://8181908 see _dispatch_lane_resume
if (dx_metatype(dq) == _DISPATCH_SOURCE_TYPE) {
dq->do_ref_cnt++; // released when DSF_DELETED is set
}
}
dq_state |= (initial_state_bits & DISPATCH_QUEUE_ROLE_MASK);
dq->do_next = DISPATCH_OBJECT_LISTLESS;
dqf |= DQF_WIDTH(width);
os_atomic_store2o(dq, dq_atomic_flags, dqf, relaxed);
dq->dq_state = dq_state;
dq->dq_serialnum =
os_atomic_inc_orig(&_dispatch_queue_serial_numbers, relaxed);
return dqu;
}
传入的第三个参数为width，猜测应该是理想情况下调度任务的数量，而width是根据dqai.dqai_concurrent开决定的，当串行队列时为1，当为并发队列时，为DISPATCH_QUEUE_WIDTH_MAX，其宏定义如下：
#define DISPATCH_QUEUE_WIDTH_FULL 0x1000ull
#define DISPATCH_QUEUE_WIDTH_POOL (DISPATCH_QUEUE_WIDTH_FULL - 1) // 0xfff
#define DISPATCH_QUEUE_WIDTH_MAX (DISPATCH_QUEUE_WIDTH_FULL - 2) // 0xffe
经过计算DISPATCH_QUEUE_WIDTH_MAX为0xffe，验证了开篇po并发队列时，打印的结果，而串行队列width为1，即：0x1，也验证了串行队列的打印。
那么，并发队列的
width为什么是-2呢？
猜测跟优先级有关，我们知道，还有一个global_queue，是一个全局并发队列，优先级高于自己创建的并发队列，打印global_queue结果如下：
其width为0xfff，即：DISPATCH_QUEUE_WIDTH_POOL，其实也可以从dispatch_queue_global的创建中看出，
在调用_dispatch_queue_init()初始化队列时，最终返回一个dispatch_queue_class_t类型对象，其本质是一个union联合体，具体如下：
typedef union {
struct dispatch_queue_s *_dq;
struct dispatch_workloop_s *_dwl;
struct dispatch_lane_s *_dl;
struct dispatch_queue_static_s *_dsq;
struct dispatch_queue_global_s *_dgq;
struct dispatch_queue_pthread_root_s *_dpq;
struct dispatch_source_s *_ds;
struct dispatch_mach_s *_dm;
dispatch_lane_class_t _dlu;
#ifdef __OBJC__
id<OS_dispatch_queue> _objc_dq;
#endif
} dispatch_queue_class_t DISPATCH_TRANSPARENT_UNION;
使用 联合体（属性之间互斥的，有你无他） 类型是为了更多元的多态，多态一般通过继承的形式，但是内存还是有消耗，在内存，性能开辟的更多一些，利用 联合体，属性可以转换，限制多方面的变化，性能方面优于继承。
从上面的分析得知，大部分队列（除主队列）都是根据模板从_dispatch_root_queues[]中来的，而其中有很多已经创建好的队列，那么是在什么时候创建的呢？
在前面的程序启动流程的学习中，曾提到，在启动时，会调用read_images()初始化一系列操作，然后调用_os_object_init()初始化，其实，在这之后，后调用_dispatch_introspection_init()方法。
_dispatch_introspection_init源码如下：
void
_dispatch_introspection_init(void)
{
_dispatch_introspection.debug_queue_inversions =
_dispatch_getenv_bool("LIBDISPATCH_DEBUG_QUEUE_INVERSIONS", false);
// Hack to determine queue TSD offset from start of pthread structure
uintptr_t thread = _dispatch_thread_self();
thread_identifier_info_data_t tiid;
mach_msg_type_number_t cnt = THREAD_IDENTIFIER_INFO_COUNT;
kern_return_t kr = thread_info(pthread_mach_thread_np((void*)thread),
THREAD_IDENTIFIER_INFO, (thread_info_t)&tiid, &cnt);
if (!dispatch_assume_zero(kr)) {
_dispatch_introspection.thread_queue_offset =
(void*)(uintptr_t)tiid.dispatch_qaddr - (void*)thread;
}
_dispatch_thread_key_create(&dispatch_introspection_key,
_dispatch_introspection_thread_remove);
_dispatch_introspection_thread_add(); // add main thread
// ✅ 初始化创建_dispatch_root_queues
for (size_t i = 0; i < DISPATCH_ROOT_QUEUE_COUNT; i++) {
_dispatch_trace_queue_create(&_dispatch_root_queues[i]);
}
#if DISPATCH_USE_MGR_THREAD && DISPATCH_USE_PTHREAD_ROOT_QUEUES
_dispatch_trace_queue_create(_dispatch_mgr_q.do_targetq);
#endif
// ✅ 初始化 main_queue
_dispatch_trace_queue_create(&_dispatch_main_q);
_dispatch_trace_queue_create(&_dispatch_mgr_q);
}
由此可以看到，_dispatch_root_queues和main_queue在程序启动的时候，就被常见初始化，而main_queqe的底层实现是一个全局静态结构体
这也是main_queqe能在任何地方都可以被拿到的原因。
2. 异步/同步函数分析
首先看下面一段代码：
int a = 0;
while (a < 10) {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
a++;
});
}
NSLog(@"外面 a = %d", a);
-
第一问：上面的代码有什么问题？怎么修改？
这一问很简单，在
block内部修改外部变量的值，要用__block修饰。 -
第二问：修改后，外面打印
a的值为多少？外部打印
a的值为大于等于10，在while循环中，是一个异步函数，并发队列，会创建子线程，然后对a++，由于block中的代码是耗时操作，在a++没有执行完返回时，就会去创建另外很多的线程，在某一时刻，耗时操作执行完成后，对a++时，可能同时又多条线程执行完，而操作的a++是同一个变量，比如当a = 8时，同时有5条线程回来，对a++，然后a = 13，然后跳出循环，打印出a的结果大于等于10。 -
第三问：用
FIFO的思想，瑕疵设计，输出最终a的值。可以在
global_queue中添加一个任务，等前面的a++任务全部执行完时，打印a的值，可以添加一个延时，如下：
dispatch_async(dispatch_get_global_queue(0, 0), ^{
sleep(2);
NSLog(@"外面 a = %d", a);
});
由于不知道，a++任务什么时候全部执行完，无法确定延时时间，所以存在一定的瑕疵。
-
第四问：怎么不浪费性能，打印出
a = 10呢？使用栅栏函数，信号量，同步等，信号量示例如下：
dispatch_semaphore_t sem = dispatch_semaphore_create(1);
__block int a = 0;
while (a < 10) {
dispatch_async(dispatch_get_global_queue(0, 0), ^{
a++;
dispatch_semaphore_signal(sem);
});
dispatch_semaphore_wait(sem, DISPATCH_TIME_FOREVER);
}
NSLog(@"外面 a = %d", a);
