GCD原理分析中篇

时间  2021-08-12
标签 markdown 并发 异步 async 函数 post spa code orm 栏目 Markdown 繁體版
原文   原文链接

这是我参与8月更文挑战的第4天，活动详情查看：8月更文挑战markdown

_dispatch_object_alloc

在creat的底层源码中，申请和开辟内存使用的是这行代码:并发

dispatch_lane_t dq = _dispatch_object_alloc(vtable,
			sizeof(struct dispatch_lane_s));
复制代码

_dispatch_object_alloc作了什么？从源码一窥究竟异步

void *
_dispatch_object_alloc(const void *vtable, size_t size)
{
#if OS_OBJECT_HAVE_OBJC1
	const struct dispatch_object_vtable_s *_vtable = vtable;
	dispatch_object_t dou;
	dou._os_obj = _os_object_alloc_realized(_vtable->_os_obj_objc_isa, size);
	dou._do->do_vtable = vtable;
	return dou._do;
#else
	return _os_object_alloc_realized(vtable, size);
#endif
}
复制代码

_dispatch_object_alloc -> _os_object_alloc_realizedasync

_os_object_t
_os_object_alloc_realized(const void *cls, size_t size)
{
	dispatch_assert(size >= sizeof(struct _os_object_s));
	return _os_objc_alloc(cls, size);
}
复制代码

_dispatch_object_alloc -> _os_object_alloc_realized -> _os_objc_alloc 果真是在开辟内存空间函数

GCD底层源码继承链

在研究上面的问题以前，咱们继续来查看全局队列的源码 image.pngpost

  • 主队列的类型是：dispatch_queue_main_t
  • 全局队列的类型是:dispatch_queue_global_s

由代码咱们知道，无论是全局队列仍是主队列都是能够使用dispatch_queue_t来接收的 DISPATCH_DECL(dispatch_queue);ui

#define DISPATCH_DECL(name) OS_OBJECT_DECL_SUBCLASS(name, dispatch_object)spa

也就等价于 OS_OBJECT_DECL_SUBCLASS(dispatch_queue, dispatch_object)继续点击，发现跳不进去了，因此咱们须要到源码里面去看了code

#define OS_OBJECT_DECL_SUBCLASS(name, super) \ OS_OBJECT_DECL_IMPL(name, NSObject, <OS_OBJECT_CLASS(super)>)
#define OS_OBJECT_DECL_SUBCLASS(name, super) DISPATCH_DECL(name)
复制代码

全局搜索了以后，定位到了这两处的宏定义，然而咱们发现第二处的宏定义正是咱们进来的地方，因此此次没有研究的意义了。主要看第一个等价于orm

OS_OBJECT_DECL_IMPL(dispatch_queue, NSObject, <OS_OBJECT_CLASS(dispatch_object)>)

#define OS_OBJECT_DECL_IMPL(name, adhere, ...) \ OS_OBJECT_DECL_PROTOCOL(name, __VA_ARGS__) \ typedef adhere<OS_OBJECT_CLASS(name)> \ * OS_OBJC_INDEPENDENT_CLASS name##_t
复制代码

等价于:

OS_OBJECT_DECL_PROTOCOL(dispatch_queue, dispatch_object) typedef NSObject<OS_dispatch_queue)> * OS_OBJC_INDEPENDENT_CLASS dispatch_queue_t

#define OS_OBJECT_DECL_PROTOCOL(name, ...) \ @protocol OS_OBJECT_CLASS(name) __VA_ARGS__ \ @end
复制代码

等价于:

@protocol OS_OBJECT_CLASS(dispatch_queue) dispatch_object @end

#define OS_OBJECT_CLASS(name) OS_##name
复制代码

等价于:

OS_dispatch_queue

或者还有一个更简单的:

#define DISPATCH_DECL(name) \ typedef struct name##_s : public dispatch_object_s {} *name##_t
typedef struct dispatch_queue_s: public dispatch_object_s {} *dispatch_queue_t
复制代码

因此能够得出结论： dispatch_queue_t底层是一个结构体dispatch_queue_s继承于dispatch_object_s能够类比class，咱们知道class的底层继承关系

class -> object_class -> object_object

dispatch_queue_t -> dispatch_queue_s -> dispatch_object_s -> _os_object_s ->dispatch_object_t

dispatch_queue_s

就跟研究类同样，可想而知咱们重点研究的是dispatch_queue_s

struct dispatch_queue_s {
	DISPATCH_QUEUE_CLASS_HEADER(queue, void *__dq_opaque1);
	/* 32bit hole on LP64 */
} DISPATCH_ATOMIC64_ALIGN;

复制代码

继续搜索DISPATCH_QUEUE_CLASS_HEADER

#define _DISPATCH_QUEUE_CLASS_HEADER(x, __pointer_sized_field__) \ DISPATCH_OBJECT_HEADER(x); \ DISPATCH_UNION_LE(uint64_t volatile dq_state, \ dispatch_lock dq_state_lock, \ uint32_t dq_state_bits \ ); \ __pointer_sized_field__
复制代码

等价于： DISPATCH_OBJECT_HEADER(queue);

#define DISPATCH_OBJECT_HEADER(x) \ struct dispatch_object_s _as_do[0]; \ _DISPATCH_OBJECT_HEADER(x)
复制代码

最终指向了dispatch_object_s,也恰好验证了上面的继承过程。接着继续搜索_DISPATCH_OBJECT_HEADER

#define _DISPATCH_OBJECT_HEADER(x) \ struct _os_object_s _as_os_obj[0]; \ OS_OBJECT_STRUCT_HEADER(dispatch_##x); \ struct dispatch_##x##_s *volatile do_next; \ struct dispatch_queue_s *do_targetq; \ void *do_ctxt; \ union { \ dispatch_function_t DISPATCH_FUNCTION_POINTER do_finalizer; \ void *do_introspection_ctxt; \ }
复制代码

咱们发现原来在dispatch_object_s后面还有一层，还继承了_os_object_s 继续搜索宏定义OS_OBJECT_STRUCT_HEADER,拆了这么多的包装以后终于拿到了dispatch_queue_s的内部结构，发现一共有3个成员变量

#define OS_OBJECT_STRUCT_HEADER(x) \ _OS_OBJECT_HEADER(\ const void *_objc_isa, \ do_ref_cnt, \ do_xref_cnt); \ const struct x##_vtable_s *do_vtable
#else
复制代码

GCD任务执行堆栈-同步

dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"同步函数分析");
    });
复制代码

咱们来研究一下这个NSLog执行的时机，仍是看源码

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);
}
复制代码

咱们只须要关注work的流向：_dispatch_sync_f关注第二个和第三个参数：ctxt, func

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_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)) {
	 // 这里有ctxt和func的调用
		return _dispatch_barrier_sync_f(dq, ctxt, func, dc_flags);
	}

	if (unlikely(dx_metatype(dq) != _DISPATCH_LANE_TYPE)) {
		DISPATCH_CLIENT_CRASH(0, "Queue type doesn't support dispatch_sync");
	}

	dispatch_lane_t dl = upcast(dq)._dl;
	// Global concurrent queues and queues bound to non-dispatch threads
	// always fall into the slow case, see DISPATCH_ROOT_QUEUE_STATE_INIT_VALUE
	if (unlikely(!_dispatch_queue_try_reserve_sync_width(dl))) {
        // // 这里有ctxt和func的调用
		return _dispatch_sync_f_slow(dl, ctxt, func, 0, dl, dc_flags);
	}

	if (unlikely(dq->do_targetq->do_targetq)) {
        // // 这里有ctxt和func的调用
		return _dispatch_sync_recurse(dl, ctxt, func, dc_flags);
	}
	_dispatch_introspection_sync_begin(dl);
    // // 这里有ctxt和func的调用
	_dispatch_sync_invoke_and_complete(dl, ctxt, func DISPATCH_TRACE_ARG(
			_dispatch_trace_item_sync_push_pop(dq, ctxt, func, dc_flags)));
}
复制代码

经过在项目中下符号断点能够发现调用了_dispatch_barrier_sync_f -> _dispatch_sync_f_slow -> _dispatch_sync_function_invoke -> _dispatch_sync_function_invoke_inline -> _dispatch_client_callout

static inline void
_dispatch_client_callout(void *ctxt, dispatch_function_t f)
{
	return f(ctxt);
}
复制代码

要验证的话很简单看项目中的堆栈或者在控制台直接bt一下就能够。 ​

GCD任务执行堆栈-异步

dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"异步函数分析");
    });
复制代码

跟上面同步函数的思路同样咱们到源码里面去分析：

void 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;

	qos = _dispatch_continuation_init(dc, dq, work, 0, dc_flags);
	_dispatch_continuation_async(dq, dc, qos, dc->dc_flags);
}
复制代码

异步函数的work通过一系列封装以后赋值给了qos,定位到了这里_dispatch_continuation_async,重点关注qos，结果这里直接return了，线索到了这里就断了

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);
}
复制代码

其实这里的dx_push是一个宏

#define dx_push(x, y, z) dx_vtable(x)->dq_push(x, y, z)
复制代码

上面的qos在第三个参数，因此咱们这里重点要研究的是dq_push(x, y, z)

image.png

直接定位到全局并发队列这里

.dq_push        = _dispatch_root_queue_push,
复制代码

_dispatch_continuation_async -> dq_push -> _dispatch_root_queue_push -> _dispatch_root_queue_push_inline -> _dispatch_root_queue_poke -> _dispatch_root_queue_poke_slow -> _dispatch_root_queues_init ->_dispatch_root_queues_init_once

static inline void
_dispatch_root_queues_init(void)
{
	dispatch_once_f(&_dispatch_root_queues_pred, NULL,
			_dispatch_root_queues_init_once);
}
复制代码

定位到了单例dispatch_once_f _dispatch_root_queues_init_once -> _dispatch_worker_thread2 -> _dispatch_root_queue_drain -> _dispatch_continuation_pop_inline -> _dispatch_continuation_invoke_inline -> _dispatch_client_callout ​

_dispatch_client_callout(void *ctxt, dispatch_function_t f)
{
	return f(ctxt); //就是一个调用执行
}
复制代码

这个异步函数过程相对比较复杂和漫长 image.png

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程