前面2篇我们了解了dispatch_queue_t的数据结构和main queue、global queue、user queue之间的参数差别和dispatch_sync()的实现，dispatch_sync
这里的fastpath(x)和slowpath(x)就相当于x，只是加了cpu指令优化，所以if(slowpath(x))相当于if(x)
dispatch_sync()
https://opensource.apple.com/tarballs/libdispatch/
void
dispatch_sync(dispatch_queue_t dq, void (^work)(void))
{
#if DISPATCH_COCOA_COMPAT
//osx下GC垃圾回收处理，最后都会调用 dispatch_sync_f
if (slowpath(dq == &_dispatch_main_q)) {
return _dispatch_sync_slow(dq, work);
}
#endif
struct Block_basic *bb = (void *)work;
//dispatch_sync最终是调用下面一行
dispatch_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
}
//block转换成block结构体和调用函数指针
void
dispatch_sync_f(dispatch_queue_t dq, void *ctxt, dispatch_function_t func)
{
//1、如果是串行queue，main queue和用户创建的sereal queue
if (fastpath(dq->dq_width == 1)) {
return dispatch_barrier_sync_f(dq, ctxt, func);
}
//2、如果do_targetq不存在，说明是global queue
if (slowpath(!dq->do_targetq)) {
// the global root queues do not need strict ordering
(void)dispatch_atomic_add2o(dq, dq_running, 2);
return _dispatch_sync_f_invoke(dq, ctxt, func);
}
//3、用户创建的concurrent queue
_dispatch_sync_f2(dq, ctxt, func);
}
1)、dispatch_barrier_sync_f :main queue 或 用户创建的 serial queue
void
dispatch_barrier_sync_f(dispatch_queue_t dq, void *ctxt,
dispatch_function_t func)
{
// 1) ensure that this thread hasn't enqueued anything ahead of this call
// 2) the queue is not suspended
//1、如果queue有任务在等待执行或已经暂停，则把任务放到链表末尾，并使用信号等待进行同步，发送一个完成信号
if (slowpath(dq->dq_items_tail) || slowpath(DISPATCH_OBJECT_SUSPENDED(dq))){
return _dispatch_barrier_sync_f_slow(dq, ctxt, func);
}
//2、如果dq->dq_running==0 则dq->dq_running=1，并返回true，否则返回false
if (slowpath(!dispatch_atomic_cmpxchg2o(dq, dq_running, 0, 1))) {
// global queues and main queue bound to main thread always falls into
// the slow case
//3、把任务放到链表末尾，并使用信号等待进行同步，发送一个完成信号
return _dispatch_barrier_sync_f_slow(dq, ctxt, func);
}
//如果dq->do_targetq->do_targetq存在，将转成到do_targetq去执行
if (slowpath(dq->do_targetq->do_targetq)) {
return _dispatch_barrier_sync_f_recurse(dq, ctxt, func);
}
//最后直接调用_dispatch_function_invoke执行block，并发送一个信号量
_dispatch_barrier_sync_f_invoke(dq, ctxt, func);
}
//这个方法是 把任务放到链表末尾，并使用信号等待进行同步
static void
_dispatch_barrier_sync_f_slow(dispatch_queue_t dq, void *ctxt,
dispatch_function_t func)
{
//封装一个结构体包含block，block的函数指针，dbss2_sema信号同步
struct dispatch_barrier_sync_slow2_s dbss2 = {
.dbss2_dq = dq,
#if DISPATCH_COCOA_COMPAT
.dbss2_func = func,
.dbss2_ctxt = ctxt,
#endif
.dbss2_sema = _dispatch_get_thread_semaphore(),
};
struct dispatch_barrier_sync_slow_s dbss = {
.do_vtable = (void *)(DISPATCH_OBJ_BARRIER_BIT |
DISPATCH_OBJ_SYNC_SLOW_BIT),
.dc_func = _dispatch_barrier_sync_f_slow_invoke,
.dc_ctxt = &dbss2,
};
//将带有同步信号的任务添加到queue的任务列表，添加任务列表上一篇讲了
_dispatch_queue_push(dq, (void *)&dbss);
//等待方法完成并调用信息量
_dispatch_thread_semaphore_wait(dbss2.dbss2_sema);
}
//这个方法是直接调用block，并且如果queue有未执行的则发送一个信号量
static void
_dispatch_barrier_sync_f_invoke(dispatch_queue_t dq, void *ctxt,
dispatch_function_t func)
{
dispatch_atomic_acquire_barrier();
_dispatch_function_invoke(dq, ctxt, func);
dispatch_atomic_release_barrier();
if (slowpath(dq->dq_items_tail)) {
return _dispatch_barrier_sync_f2(dq);
}
if (slowpath(dispatch_atomic_dec2o(dq, dq_running) == 0)) {
_dispatch_wakeup(dq);
}
}
//_dispatch_function_invoke最终调用下面的直接调用block
void
_dispatch_client_callout(void *ctxt, dispatch_function_t f)
{
return f(ctxt);
}
2)、_dispatch_sync_f_invoke:global queue
//global queue由于不需要先后顺序，直接dq_running+=2，表示运行状态，
//然后直接调用_dispatch_function_invoke来调用block，再dq_running-=2
static void
_dispatch_sync_f_invoke(dispatch_queue_t dq, void *ctxt,
dispatch_function_t func)
{
_dispatch_function_invoke(dq, ctxt, func);
if (slowpath(dispatch_atomic_sub2o(dq, dq_running, 2) == 0)) {
_dispatch_wakeup(dq);
}
}
3)、_dispatch_sync_f2:用户创建的concurrent queue，并行
static void
_dispatch_sync_f2(dispatch_queue_t dq, void *ctxt, dispatch_function_t func)
{
// 1) ensure that this thread hasn't enqueued anything ahead of this call
// 2) the queue is not suspended
//1、如果queue有任务在等待执行
if (slowpath(dq->dq_items_tail) || slowpath(DISPATCH_OBJECT_SUSPENDED(dq))){
//这个函数内部会用一个semaphore等待信号，然后调用_dispatch_function_invoke直接在本线程调用block
return _dispatch_sync_f_slow(dq, ctxt, func);
}
//2、如果queue处于暂停状态
if (slowpath(dispatch_atomic_add2o(dq, dq_running, 2) & 1)) {
//这个函数内部先唤醒队列，然后用一个semaphore等待信号，然后调用_dispatch_function_invoke直接在本线程调用block
return _dispatch_sync_f_slow2(dq, ctxt, func);
}
//如果dq->do_targetq->do_targetq存在，将转成到do_targetq去执行
if (slowpath(dq->do_targetq->do_targetq)) {
return _dispatch_sync_f_recurse(dq, ctxt, func);
}
//最后直接调用_dispatch_function_invoke在本线程执行block，
_dispatch_sync_f_invoke(dq, ctxt, func);
}
这个有没有感觉似曾相识，没错，这个跟1)差不多，唯一不同的是1)做完了后发了个完成信号
总结:
1、如果是global queue，不用管顺序，直接在当前线程调用block，这个是最简单的
2、如果是用户创建的并行queue，如果有任务在等待或queue已经暂停，先唤醒quque，然后用一个semaphore信号等待开始执行信号，最后调用_dispatch_function_invoke在本线程执行block，
3、如果是main queue或用户创建的串行queue，则queue有任务等待执行就把当前任务放到任务链表末尾，并用信号等待同步，在本线程调用block，如果没有任务在等待执行，则直接在本线程调用block，但这个最后都有一个步骤，发送一个完成信号量
