前面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，但这个最后都有一个步骤，发送一个完成信号量