c++调用gcd函数_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源码晦涩难懂，所以我只能跟着源码一步步查询和学习，有很多不足之处，请大声多多指教。