GCD之函数与队列初探

一、前言

在iOS开发过程中，我们知道多线程技术是使用最多的情况，能快速的执行多个调度任务的执行。而在多线程开发过程当中，多线程技术有好几种，其中包括pthread，NSThread，NSOperation和GCD,而GCD是整个iOS开发过程中使用最多的也是最安全的一种技术，因为GCD是基于C/C++函数的封装实现，因此线程比较安全，在多线程开发过程中为我们开发者省去了基于考虑线程安全的事情，专注开发。是多线程开发过程中的首选。

然而GCD中

*1 是如何来分配多线程的调度任务的？
*2 结构又有哪些？
*3任务的调度过程是如何调度的？

带着这一系列的问题我们开始探索GCD的函数与队列的搭配使用情况。

二、函数

在我们测试的Demo中我们执行一个相关的GCD同步函数dispatch_async，同时向编译器下一个符号断点 简单的打印一个任务

 dispatch_async(conque, ^{
        NSLog(@"12334");
    });

我们会看到当前的断点会定位到系统的libdispatch.dylib dispatch_async:

系统库定位.png

通过以上我们就知道GCD的源码在libdispatch.dylib，带着找到开源的库。怀着一个好奇的心去看看具体的GCD相关函数是如何实现，底层的调用机制又是怎么样的，接下来让我们进入函数的探索环节吧

2.1 dispatch_sync(同步函数)

我们进去到libdispatch.dylib，进行全局的搜索dispatch_sync会找到相应的函数定义

void
dispatch_sync(dispatch_queue_t dq, dispatch_block_t work)
{
    uintptr_t dc_flags = DC_FLAG_BLOCK;
    if (unlikely(_dispatch_block_has_private_data(work))) {
        return _dispatch_sync_block_with_privdata(dq, work, dc_flags);
    }
    _dispatch_sync_f(dq, work, _dispatch_Block_invoke(work), dc_flags);
}

我们能看到底层是调用了一个_dispatch_sync_f函数来实现同步函数的实现的。我们再次进入看看当前函数是如何实现的

static void
_dispatch_sync_f(dispatch_queue_t dq, void *ctxt, dispatch_function_t func,
        uintptr_t dc_flags)
{
    _dispatch_sync_f_inline(dq, ctxt, func, dc_flags);
}

我们从源码就能看到当前_dispatch_sync_f是通过封装一个叫_dispatch_sync_f_inline内联函数从而达到相关的同步函数

_dispatch_sync_f_inline(dispatch_queue_t dq, void *ctxt,
        dispatch_function_t func, uintptr_t dc_flags)
{
    if (likely(dq->dq_width == 1)) {
        return _dispatch_barrier_sync_f(dq, ctxt, func, dc_flags);
    }
    
    _dispatch_introspection_sync_begin(dl);
    _dispatch_sync_invoke_and_complete(dl, ctxt, func DISPATCH_TRACE_ARG(
            _dispatch_trace_item_sync_push_pop(dq, ctxt, func, dc_flags)));
}

再次顺着相应的开源的代码进入到同步函数的执行以及完成函数_dispatch_sync_invoke_and_complete

_dispatch_sync_invoke_and_complete(dispatch_lane_t dq, void *ctxt,
        dispatch_function_t func DISPATCH_TRACE_ARG(void *dc))
{
    _dispatch_sync_function_invoke_inline(dq, ctxt, func);
    _dispatch_trace_item_complete(dc);
    _dispatch_lane_non_barrier_complete(dq, 0);
}

再次进入到_dispatch_sync_function_invoke_inline的我们能看到相应的函数调用过程

_dispatch_sync_function_invoke_inline(dispatch_queue_class_t dq, void *ctxt,
        dispatch_function_t func)
{
    dispatch_thread_frame_s dtf;
    _dispatch_thread_frame_push(&dtf, dq);
    _dispatch_client_callout(ctxt, func);
    _dispatch_perfmon_workitem_inc();
    _dispatch_thread_frame_pop(&dtf);
}

最终到_dispatch_client_callout

_dispatch_client_callout(void *ctxt, dispatch_function_t f)
{
    @try {
        return f(ctxt);
    }
    @catch (...) {
        objc_terminate();
    }
}

执行步骤如下：

• 1 先给任务分配一个任务栈
• 2把当前调度任务进行入栈。让当前线程准备开始调度相关的任务
• 3 线程调度当前的任务
• 4 执行完成后把当前任务弹栈。进行相应的释放操作，

总结：同步函数的执行流程是dispatch_async -> _dispatch_sync_f -> _dispatch_sync_f_inline -> _dispatch_sync_invoke_and_complete -> _dispatch_sync_function_invoke_inline -> _dispatch_client_callout -> f(ctxt);

2.2dispatch_async(异步函数)

再次全局搜索2dispatch_async进入到相关的异步函数的定义如下：

dispatch_async(dispatch_queue_t dq, dispatch_block_t work)
{
    dispatch_continuation_t dc = _dispatch_continuation_alloc();
    uintptr_t dc_flags = DC_FLAG_CONSUME;
    dispatch_qos_t qos;
    // 任务包装器 - 接受 - 保存 - 函数式
    // 保存 block 
    qos = _dispatch_continuation_init(dc, dq, work, 0, dc_flags);
    _dispatch_continuation_async(dq, dc, qos, dc->dc_flags);
}

我们通过代码知道，异步函数是通过一个包装器进行相应的任务包装，然后进行相应的函数执行：进入到_dispatch_continuation_async一探究竟；源码如下

static inline void
_dispatch_continuation_async(dispatch_queue_class_t dqu,
        dispatch_continuation_t dc, dispatch_qos_t qos, uintptr_t dc_flags)
{
#if DISPATCH_INTROSPECTION
    if (!(dc_flags & DC_FLAG_NO_INTROSPECTION)) {
        _dispatch_trace_item_push(dqu, dc);
    }
#else
    (void)dc_flags;
#endif
    return dx_push(dqu._dq, dc, qos);
}

我们知道如果当前是GCD的调用会走_dispatch_trace_item_push,所以进入到源码一探究竟

_dispatch_trace_item_push(dispatch_queue_class_t dqu, dispatch_object_t _tail)
{
    _dispatch_trace_item_push_inline(dqu._dq, _tail._do);
    _dispatch_introspection_queue_push(dqu, _tail);
}

顺着源码进入第一个函数去初探，我们能看到是一个任务队列封装器，目的就是通过赋值和相应的操作以返回一个全新的任务队列。有兴趣的朋友可以自行去研究了一下；而实际调用过程是第二个函数_dispatch_introspection_queue_push

static inline void
_dispatch_introspection_queue_push(dispatch_queue_class_t dqu,
        dispatch_object_t dou)
{
    _dispatch_introspection_queue_item_enqueue(dqu, dou);
}

再次进入底层_dispatch_introspection_queue_item_enqueue

_dispatch_introspection_queue_item_enqueue(dispatch_queue_t dq,
        dispatch_object_t dou)
{
    DISPATCH_INTROSPECTION_INTERPOSABLE_HOOK_CALLOUT(
            queue_item_enqueue, dq, dou);
    if (DISPATCH_INTROSPECTION_HOOK_ENABLED(queue_item_enqueue)) {
        _dispatch_introspection_queue_item_enqueue_hook(dq, dou);
    }
}

到最终我们看到调用的关键字段_dispatch_introspection_queue_item_enqueue_hook

_dispatch_introspection_queue_item_enqueue_hook(dispatch_queue_t dq,
        dispatch_object_t dou)
{
    dispatch_introspection_queue_item_s diqi;
    diqi = dispatch_introspection_queue_item_get_info(dq, dou._dc);
    dispatch_introspection_hook_callout_queue_item_enqueue(dq, &diqi);
}

我们看到最终异步函数的调用是通过封装的宏定义函数执行的

#define DISPATCH_INTROSPECTION_HOOK_CALLOUT(h, ...) ({ \
        __typeof__(_dispatch_introspection_hooks.h) _h; \
        _h = _dispatch_introspection_hooks.h; \
        if (unlikely((void*)(_h) != DISPATCH_INTROSPECTION_NO_HOOK)) { \
            _h(__VA_ARGS__); \
        } })

总结：异步函数的执行流程是 dispatch_async -> _dispatch_continuation_async -> _dispatch_trace_item_push -> _dispatch_introspection_queue_push -> _dispatch_introspection_queue_item_enqueue -> _dispatch_introspection_queue_item_enqueue_hook -> DISPATCH_INTROSPECTION_HOOK_CALLOUT

三、队列

我们都知道在iOS开发过程当中或者是任何一门操作系统语言中，队列都是一个很重要的数据结构，它有着FIFO(先进先出)原则，根据操作系统内核的不同，队列又划分为串行队列 和 并发队列。
接下来就让我们从不同的地方取分析这两种队列。

3.1 串行队列

串行队列的概念

所有的调度任务进入到任务栈以后，就由CPU统一调度，最先进去的任务先调度，在调度任务未完成之前，其他任务不能被调度。这就是串行队列，也就是相当于排队买票，一个一个来的进行。

串行队列结构.png

串行队列的结构

我们在测试Demo中创建iOS开发过程中的常用几种队列，mainQueue,serialQueue,globalQueue,以及concurrentQueue, 并且答应相关类的结构可知

 dispatch_queue_t serial = dispatch_queue_create("cooci", DISPATCH_QUEUE_SERIAL);
    // OS_dispatch_queue_concurrent
    dispatch_queue_t conque = dispatch_queue_create("cooci", DISPATCH_QUEUE_CONCURRENT);
    // DISPATCH_QUEUE_SERIAL max && 1
    // queue 对象 alloc init class
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
    // 多个 - 集合
    dispatch_queue_t globQueue = dispatch_get_global_queue(0, 0);
    
    NSLog(@"%@-%@-%@-%@",serial,conque,mainQueue,globQueue);

打印结果如下

---

所以从上我们知道了主队列也是串行队列，只是不同于一般的串行队列而已，从iOS GCD文档中已经标记的很明白了。那么串行队列的底层源码是如何实现的呢？我们继续探索

我们从以上的打印结果中知道，主队列的打印结果是OS_dispatch_queue_main: com.apple.main-thread,我们进入源码搜索主线程的结果 能看到相应的队列定义

struct dispatch_queue_static_s _dispatch_main_q = {
    DISPATCH_GLOBAL_OBJECT_HEADER(queue_main),
#if !DISPATCH_USE_RESOLVERS
    .do_targetq = _dispatch_get_default_queue(true),
#endif
    .dq_state = DISPATCH_QUEUE_STATE_INIT_VALUE(1) |
            DISPATCH_QUEUE_ROLE_BASE_ANON,
    .dq_label = "com.apple.main-thread",
    .dq_atomic_flags = DQF_THREAD_BOUND | DQF_WIDTH(1),
    .dq_serialnum = 1,
};

3.2 并发队列

并发队列的概念：

所有的调度任务进入到任务栈以后，就由CPU统一调度，最先进去的任务先调度，但是由于计算机的CPU 在短暂的时间内可以对多个调度任务进行处理，利用时间片轮转发来进行任务的调度，所以就好像多个调度任务同时执行的意思；

并发队列结构.png

并发队列的结构

我们从以上的打印结果中知道，主队列的打印结果是OS_dispatch_queue_concurrent,我们进入源码搜索主线程的结果 能看到相应的队列定义

struct dispatch_queue_global_s _dispatch_root_queues[] = {
_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,
    ),

3.3 队列如何创建的并且关联类信息

我们在打印的结果中已经知道串行队列打印的结构是OS_dispatch_queue_serial ，并发队列打印的结构是OS_dispatch_queue_concurrent,接下来就让我们进入源码看看队列是如何关联类对象并且isa指针的，
首先我们进入到dispatch_queue_create函数看看源码

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

static dispatch_queue_t
_dispatch_lane_create_with_target(const char *label, dispatch_queue_attr_t dqa,
        dispatch_queue_t tq, bool legacy)
{
    // dqai 创建 -
    dispatch_queue_attr_info_t dqai = _dispatch_queue_attr_to_info(dqa);

    //
    // Step 1: Normalize arguments (qos, overcommit, tq)
    //
dispatch_lane_t dq = _dispatch_object_alloc(vtable,
            sizeof(struct dispatch_lane_s)); // alloc
    _dispatch_queue_init(dq, dqf, dqai.dqai_concurrent ?
            DISPATCH_QUEUE_WIDTH_MAX : 1, DISPATCH_QUEUE_ROLE_INNER |
            (dqai.dqai_inactive ? DISPATCH_QUEUE_INACTIVE : 0)); // init

    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;
    _dispatch_object_debug(dq, "%s", __func__);
    return _dispatch_trace_queue_create(dq)._dq;

就这样能进行相关的队列的创建过程；

以上创建过程中如果需要进行相应的串行和并发的判断

const void *vtable;
    dispatch_queue_flags_t dqf = legacy ? DQF_MUTABLE : 0;
    if (dqai.dqai_concurrent) {
        // OS_dispatch_queue_concurrent
        vtable = DISPATCH_VTABLE(queue_concurrent);
    } else {
        vtable = DISPATCH_VTABLE(queue_serial);
    }

然后我们进入到DISPATCH_VTABLE中去看看是如何决定一个队列是串行还是并发的

我们能找到相应的宏定义是

define DISPATCH_VTABLE(name) DISPATCH_OBJC_CLASS(name)

再次搜索DISPATCH_OBJC_CLASS

我们也知道当前是一个宏定义如下

#define OS_OBJECT_VTABLE(name)      (&OS_OBJECT_CLASS_SYMBOL(name))
#define DISPATCH_OBJC_CLASS(name)   (&DISPATCH_CLASS_SYMBOL(name))

我们再次全局搜索DISPATCH_CLASS_SYMBOL就能找到定义如下

#define OS_OBJECT_EXTRA_VTABLE_SYMBOL(name) _OS_##name##_vtable
#define DISPATCH_CLASS_SYMBOL(name) OS_dispatch_##name##_class

从以上的源码定义我们就知道系统是通过拼接名字进行的

通过以上创建的类进行名字拼接就得到我们自己所定义的类。这就是队列创建和关联的过程。

四、总结

以上就是本人对队列的创建和函数底层源码的调用过程的学习，由于libdispatch源码晦涩难懂，所以我只能跟着源码一步步查询和学习，有很多不足之处，请大声多多指教。