深入理解GCD

       
字数统计: 4.1k字   |   阅读时长: 18min

最近看到了一些关于GCD的一些问题,看了下不是很清楚,发现这些问题还是很有意思的, 所以决定研究下GCD的源码,过程中还是找到了很多神奇的地方,作为学习的记录,于是写下了这个文章作为学习的笔记。。。
看的时候是最新的 libdispatch-84.5.tar.gz 的版本，这个版本跟之前版本不太一样，不过总体上没有太大的改变。。。

1. dispatch_async 函数如何实现，分发到主队列和全局队列有什么区别，一定会新建线程执行任务么？
2. dispatch_sync 函数如何实现，为什么说 GCD 死锁是队列导致的而不是线程，死锁不是操作系统的概念么？
3. 信号量是如何实现的，有哪些使用场景？
4. dispatch_group 的等待与通知,dispatch_once 如何实现？
5. dispatch_source 用来做定时器如何实现，有什么优点和用途？
6. dispatch_suspend 和 dispatch_resume 如何实现，队列的的暂停和计时器的暂停有区别么？
打开源码，我们能看到大概的结构，先来看下提供给我们的接口:

接下来，分析下开发常用到一些函数。

dispatch_once

1
2
3
4
void dispatch_once(dispatch_once_t *val, void (^block)(void)) {
	struct Block_basic *bb = (void *)block;
	dispatch_once_f(val, block, (void *)bb->Block_invoke);
} 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
void dispatch_once_f(dispatch_once_t *val, void *ctxt, void (*func)(void *)) {
	volatile long *vval = val;
	
	if (dispatch_atomic_cmpxchg(val, 0l, 1l)) {
		func(ctxt);	
		dispatch_atomic_barrier();
		*val = ~0l;
	} else {
		do {
			_dispatch_hardware_pause();
		} while (*vval != ~0l);

		dispatch_atomic_barrier();
	}
}

这个函数官方文档的是这样描述的, “Executes a block object once and only once for the lifetime of an application.” 就是说在程序的生命周期内block只执行一次.
dispatch_once 函数内部调用了 dispatch_once_f, 在dispatch_once_f中发现了几个奇怪的宏.
  • dispatch_atomic_cmpxchg: #define dispatch_atomic_cmpxchg(p, o, n) __sync_bool_compare_and_swap((p), (o), (n)) …what ?? __sync_bool_compare_and_swap 这是个什么玩意？？查了下发现这是一种原子操作的一种技术CAS, CAS可以用于实现无锁数据结构, 这里就不展开了
  • dispatch_atomic_barrier : 
1
2
3
4
5
6
7
8
9
#if defined(__i386__) || defined(__x86_64__)
/* GCC emits nothing for __sync_synchronize() on i386/x86_64. */
#define dispatch_atomic_barrier()	__asm__ __volatile__("mfence")
#else
#define dispatch_atomic_barrier()	__sync_synchronize()
#endif
#else
#error "Please upgrade to GCC 4.2 or newer."
#endif

这个宏定义在不同的系统架构上有不同的实现, 其实就是一种原子操作

  • _dispatch_hardware_pause : #define _dispatch_hardware_pause() asm("pause"), pause是一个汇编指令
函数在执行的时候,传进来一个类型为dispatch_once_t 的参数，dispatch_once_t 这个类型其实就是long类型, * val如果没有初始化则值为0, 当走到if的时候, 与0比较相等,dispatch_atomic_cmpxchg 返回了YES, 就会执行func函数,其实就是外面传进来的block, 并把*val 置成1, 如果第二次再走这个函数, dispatch_atomic_cmpxchg 则会返回NO, 就只会走else后面的语句, block就不会再执行了, 所以这就能保证dispatch_once 函数只能执行一次的原因,其核心就是__sync_bool_compare_and_swap((p),(o),(n))。
PS: 平时我们在开发时,经常会用这个函数来写单例,
1
2
3
4
5
6
7
8
+ (id)sharedInstance {
    static Class *_sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _sharedInstance = [[self alloc] init];
    });
    return _sharedInstance;
}

假设我们需要把这个单例释放,我们可以把static Class *_sharedInstance = nil;这一句放到函数外边, 外面直接将_sharedInstance置空即可,但是如果需要重新创建单例的话, 则还需要把onceToken置为0, 不置为0的话就不会走block了。

dispatch_async

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
void dispatch_async(dispatch_queue_t dq, void (^work)(void)) {
	dispatch_async_f(dq, _dispatch_Block_copy(work), _dispatch_call_block_and_release);
}

void dispatch_async_f(dispatch_queue_t dq, void *ctxt, dispatch_function_t func) {
	dispatch_continuation_t dc = fastpath(_dispatch_continuation_alloc_cacheonly());

	// unlike dispatch_sync_f(), we do NOT need to check the queue width,
	// the "drain" function will do this test

	if (!dc) {
		return _dispatch_async_f_slow(dq, ctxt, func);
	}

	dc->do_vtable = (void *)DISPATCH_OBJ_ASYNC_BIT;
	dc->dc_func = func;
	dc->dc_ctxt = ctxt;

	_dispatch_queue_push(dq, dc);
}

“Submits a block for asynchronous execution on a dispatch queue and returns immediately.” 在一个队列提交一个异步执行的block,并立刻返回.

dispatch_async 内部执行了dispatch_async_f ,把block转成了function执行~~在这里我们发现了 fastpath 这个神奇的东西, 点进去这个宏。。发现是一个__builtin_expect函数,这个可以用来优化执行速度的

  • fastpath表示条件更可能成立
  • slowpath表示条件更不可能成立
1
2
#define fastpath(x)	((typeof(x))__builtin_expect((long)(x), ~0l))
#define slowpath(x)	((typeof(x))__builtin_expect((long)(x), 0l))

先从_dispatch_continuation_alloc_cacheonly取出是否有cache的dc；若有dc存在，那么给dc赋值，然后push到dq中去；假设没有cache，那么进入到_dispatch_async_f_slow 创建一个dispatch_continuation对象(从堆中获取)来存放function，然后push到队列后面, 我们先来看下 

1
2
3
4
5
6
7
8
static inline dispatch_continuation_t _dispatch_continuation_alloc_cacheonly(void) {
	dispatch_continuation_t dc = fastpath(_dispatch_thread_getspecific(dispatch_cache_key));
	if (dc) {
		_dispatch_thread_setspecific(dispatch_cache_key, dc->do_next);
	}
	return dc;
}

这里我们用到了TSD(Thread-Specific Data) 也就是线程私有数据。这里不展开。如果能取到dc, 则为它设置线程私有数据并返回.

dc->do_vtable = (void *)DISPATCH_OBJ_ASYNC_BIT

GCD队列的异步就是通过DISPATCH_OBJ_ASYNC_BIT 这个bit标识来实现的，全部的标识有如下几种:

1
2
3
#define DISPATCH_OBJ_ASYNC_BIT	0x1  // 异步
#define DISPATCH_OBJ_BARRIER_BIT	0x2  // 阻塞
#define DISPATCH_OBJ_GROUP_BIT	0x4  // 组

dispatch_sync

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
void dispatch_sync(dispatch_queue_t dq, void (^work)(void)) {
#if DISPATCH_COCOA_COMPAT
	if (slowpath(dq == &_dispatch_main_q)) {
		return _dispatch_sync_slow(dq, work);
	}
#endif
	struct Block_basic *bb = (void *)work;
	dispatch_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
}

void dispatch_sync_f(dispatch_queue_t dq, void *ctxt, dispatch_function_t func) {
	typeof(dq->dq_running) prev_cnt;
	dispatch_queue_t old_dq;

	if (dq->dq_width == 1) {
		return dispatch_barrier_sync_f(dq, ctxt, func);
	}

	// 1) ensure that this thread hasn't enqueued anything ahead of this call
	// 2) the queue is not suspended
	if (slowpath(dq->dq_items_tail) || slowpath(DISPATCH_OBJECT_SUSPENDED(dq))) {
		_dispatch_sync_f_slow(dq);
	} else {
		prev_cnt = dispatch_atomic_add(&dq->dq_running, 2) - 2;

		if (slowpath(prev_cnt & 1)) {
			if (dispatch_atomic_sub(&dq->dq_running, 2) == 0) {
				_dispatch_wakeup(dq);
			}
			_dispatch_sync_f_slow(dq);
		}
	}

	old_dq = _dispatch_thread_getspecific(dispatch_queue_key);
	_dispatch_thread_setspecific(dispatch_queue_key, dq);
	func(ctxt);
	_dispatch_workitem_inc();
	_dispatch_thread_setspecific(dispatch_queue_key, old_dq);

	if (slowpath(dispatch_atomic_sub(&dq->dq_running, 2) == 0)) {
		_dispatch_wakeup(dq);
	}
}

“Submits a block object for execution on a dispatch queue and waits until that block completes.” 这个函数是在一个队列提交一个执行的block,并需要等待block必须执行完之后函数才返回.

发现dispatch_sync 无论走哪个分支，最后走的都是dispatch_sync_f,通过_dispatch_Block_copy或者Block_basic来实现block到function的转换.
如果是串行队列(dq_width==1)的话必须要等待前面的任务执行完成之后才能执行该任务,然后调用dispatch_barrier_sync_f,barrier的实现是依靠信号量机制来同步任务的执行.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void dispatch_barrier_sync_f(dispatch_queue_t dq, void *ctxt,dispatch_function_t func) {
	dispatch_queue_t old_dq = _dispatch_thread_getspecific(dispatch_queue_key);

	// 1) ensure that this thread hasn't enqueued anything ahead of this call
	// 2) the queue is not suspended
	// 3) the queue is not weird
	if (slowpath(dq->dq_items_tail)
			|| slowpath(DISPATCH_OBJECT_SUSPENDED(dq))
			|| slowpath(!_dispatch_queue_trylock(dq))) {
		return _dispatch_barrier_sync_f_slow(dq, ctxt, func);
	}

	_dispatch_thread_setspecific(dispatch_queue_key, dq);
	func(ctxt);
	_dispatch_workitem_inc();
	_dispatch_thread_setspecific(dispatch_queue_key, old_dq);
	_dispatch_queue_unlock(dq);
}

如果当前是处于队列尾部,队列不为暂停状态,且使用_dispatch_queue_trylock检查队列则会执行_dispatch_barrier_sync_f_slow函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
static void _dispatch_barrier_sync_f_slow(dispatch_queue_t dq, void *ctxt, dispatch_function_t func) {
	
	// It's preferred to execute synchronous blocks on the current thread
	// due to thread-local side effects, garbage collection, etc. However,
	// blocks submitted to the main thread MUST be run on the main thread
	
	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 {
		DISPATCH_CONTINUATION_HEADER(dispatch_barrier_sync_slow_s);
	} dbss = {
		.do_vtable = (void *)DISPATCH_OBJ_BARRIER_BIT,
		.dc_func = _dispatch_barrier_sync_f_slow_invoke,
		.dc_ctxt = &dbss2,
	};
	
	===============================Important=============================
	_dispatch_queue_push(dq, (void *)&dbss);
	dispatch_semaphore_wait(dbss2.dbss2_sema, DISPATCH_TIME_FOREVER);
	_dispatch_put_thread_semaphore(dbss2.dbss2_sema);

#if DISPATCH_COCOA_COMPAT
	// Main queue bound to main thread
	if (dbss2.dbss2_func == NULL) {
		return;
	}
#endif
	dispatch_queue_t old_dq = _dispatch_thread_getspecific(dispatch_queue_key);
	_dispatch_thread_setspecific(dispatch_queue_key, dq);
	func(ctxt);
	_dispatch_workitem_inc();
	_dispatch_thread_setspecific(dispatch_queue_key, old_dq);
	dispatch_resume(dq);
}

在函数中，使用_dispatch_queue_push将我们的block压入main queue的FIFO队列中，然后等待信号量，ready后被唤醒. 假如我们调用的dispatch_sync函数一直不返回,而且main queue被阻塞，而我们的block又需要等待main queue来执行它, 就会出现死锁. 所以 GCD 死锁是队列导致的而不是线程.

dispatch_after

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
void dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t work) {
	// test before the copy of the block
	if (when == DISPATCH_TIME_FOREVER) {
		return;
	}
	dispatch_after_f(when, queue, _dispatch_Block_copy(work), _dispatch_call_block_and_release);
}

void dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue, void *ctxt, void (*func)(void *)) {
	uint64_t delta;
	if (when == DISPATCH_TIME_FOREVER) {
		return;
	}
	// this function can and should be optimized to not use a dispatch source
again:
	delta = _dispatch_timeout(when);
	if (delta == 0) {
		return dispatch_async_f(queue, ctxt, func);
	}
	if (!dispatch_source_timer_create(DISPATCH_TIMER_INTERVAL, delta, 0, NULL, queue, ^(dispatch_source_t ds) {
		long err_dom, err_val;
		if ((err_dom = dispatch_source_get_error(ds, &err_val))) {
			dispatch_assert(err_dom == DISPATCH_ERROR_DOMAIN_POSIX);
			dispatch_assert(err_val == ECANCELED);
			func(ctxt);
			dispatch_release(ds);	// MUST NOT be _dispatch_release()
		} else {
			dispatch_source_cancel(ds);
		}
	})) {
		goto again;
	}
}

“Enqueue a block for execution at the specified time.” 延时提交用于执行的block.

同上内部会走dispatch_after_f 这个函数,实现将block跟function之间的转换, 如果外面传进来的时间为DISPATCH_TIME_FOREVER ,则直接返回, when为0, 则执行dispatch_async_f ,内部是依赖dispatch_source定时器来实现延迟执行, 如果没有使用到dispatch source, function则会被优化。

dispatch_ get_ global_queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
dispatch_queue_t dispatch_get_global_queue(long priority, unsigned long flags) {
	if (flags & ~DISPATCH_QUEUE_OVERCOMMIT) {
		return NULL;
	}
	return _dispatch_get_root_queue(priority, flags & DISPATCH_QUEUE_OVERCOMMIT);
}

static inline dispatch_queue_t _dispatch_get_root_queue(long priority, bool overcommit) {
	if (overcommit) switch (priority) {
	case DISPATCH_QUEUE_PRIORITY_LOW:
		return &_dispatch_root_queues[1];
	case DISPATCH_QUEUE_PRIORITY_DEFAULT:
		return &_dispatch_root_queues[3];
	case DISPATCH_QUEUE_PRIORITY_HIGH:
		return &_dispatch_root_queues[5];
	}
	switch (priority) {
	case DISPATCH_QUEUE_PRIORITY_LOW:
		return &_dispatch_root_queues[0];
	case DISPATCH_QUEUE_PRIORITY_DEFAULT:
		return &_dispatch_root_queues[2];
	case DISPATCH_QUEUE_PRIORITY_HIGH:
		return &_dispatch_root_queues[4];
	default:
		return NULL;
	}
}

“Returns a system-defined global concurrent queue with the specified quality of service class.” 返回一个系统定义的全局并发队列, 并可以指定执行的服务质量

我们会看到有个DISPATCH_QUEUE_OVERCOMMIT 这么个玩意。。点进去看。发现官方是这么描述的, 首先它是一个枚举, 系统会开启一个新的线程去执行block, 无论此时计算机有多忙~ OVERCOMMIT用来控制线程数能不能超越物理内核数

1
2
3
4
5
6
7
8
9
10
/*!
 * @enum dispatch_queue_flags_t
 *
 * @constant DISPATCH_QUEUE_OVERCOMMIT
 * The queue will create a new thread for invoking blocks, regardless of how
 * busy the computer is.
 */
enum {
	DISPATCH_QUEUE_OVERCOMMIT = 0x2ull,
};

通过此方法_dispatch_get_root_queue获取对应的一个全局队列。有这三种优先级以及是否是OVERCOMMIT

1
2
3
4
5
enum {
	DISPATCH_QUEUE_PRIORITY_HIGH = 2,
	DISPATCH_QUEUE_PRIORITY_DEFAULT = 0,
	DISPATCH_QUEUE_PRIORITY_LOW = -2,
};

接下来我们来看一个图, 图中描述了线程和队列的关系

每一个_dispatch_root_queue包含一个线程池_dispatch_root_queue_context
4-9是全局队列,1是主队列,2是一个管理队列,用来管理 GCD内部任务, 3暂时没使用. 队列 的 dq_width 被设置为 UINT32_MAX，表示这些队列不限制并发数.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
static struct dispatch_queue_s _dispatch_root_queues[] = {
	{
		.do_vtable = &_dispatch_queue_root_vtable,
		.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
		.do_ctxt = &_dispatch_root_queue_contexts[0],

		.dq_label = "com.apple.root.low-priority",
		.dq_running = 2,
		.dq_width = UINT32_MAX,
		.dq_serialnum = 4,
	},
	{
		.do_vtable = &_dispatch_queue_root_vtable,
		.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
		.do_ctxt = &_dispatch_root_queue_contexts[1],

		.dq_label = "com.apple.root.low-overcommit-priority",
		.dq_running = 2,
		.dq_width = UINT32_MAX,
		.dq_serialnum = 5,
	},
	{
		.do_vtable = &_dispatch_queue_root_vtable,
		.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
		.do_ctxt = &_dispatch_root_queue_contexts[2],

		.dq_label = "com.apple.root.default-priority",
		.dq_running = 2,
		.dq_width = UINT32_MAX,
		.dq_serialnum = 6,
	},
	{
		.do_vtable = &_dispatch_queue_root_vtable,
		.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
		.do_ctxt = &_dispatch_root_queue_contexts[3],

		.dq_label = "com.apple.root.default-overcommit-priority",
		.dq_running = 2,
		.dq_width = UINT32_MAX,
		.dq_serialnum = 7,
	},
	{
		.do_vtable = &_dispatch_queue_root_vtable,
		.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
		.do_ctxt = &_dispatch_root_queue_contexts[4],

		.dq_label = "com.apple.root.high-priority",
		.dq_running = 2,
		.dq_width = UINT32_MAX,
		.dq_serialnum = 8,
	},
	{
		.do_vtable = &_dispatch_queue_root_vtable,
		.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
		.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
		.do_ctxt = &_dispatch_root_queue_contexts[5],

		.dq_label = "com.apple.root.high-overcommit-priority",
		.dq_running = 2,
		.dq_width = UINT32_MAX,
		.dq_serialnum = 9,
	},
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#define MAX_THREAD_COUNT 255

struct dispatch_root_queue_context_s {
	pthread_workqueue_t dgq_kworkqueue;
	uint32_t dgq_pending;
	uint32_t dgq_thread_pool_size;
	dispatch_semaphore_t dgq_thread_mediator;
};

#define DISPATCH_ROOT_QUEUE_COUNT (DISPATCH_QUEUE_PRIORITY_COUNT * 2)
static struct dispatch_root_queue_context_s _dispatch_root_queue_contexts[] = {
	{
		.dgq_thread_mediator = &_dispatch_thread_mediator[0],
		.dgq_thread_pool_size = MAX_THREAD_COUNT,
	},
	{
		.dgq_thread_mediator = &_dispatch_thread_mediator[1],
		.dgq_thread_pool_size = MAX_THREAD_COUNT,
	},
	{
		.dgq_thread_mediator = &_dispatch_thread_mediator[2],
		.dgq_thread_pool_size = MAX_THREAD_COUNT,
	},
	{
		.dgq_thread_mediator = &_dispatch_thread_mediator[3],
		.dgq_thread_pool_size = MAX_THREAD_COUNT,
	},
	{
		.dgq_thread_mediator = &_dispatch_thread_mediator[4],
		.dgq_thread_pool_size = MAX_THREAD_COUNT,
	},
	{
		.dgq_thread_mediator = &_dispatch_thread_mediator[5],
		.dgq_thread_pool_size = MAX_THREAD_COUNT,
	},
};

dispatch_root_queue_context_s 这个结构体就是队列对应的线程实现, 一个context就是一个线程池, 最大线程数为255

dispatch_ get_current _queue

1
2
3
4
5
6
7
dispatch_queue_t dispatch_get_current_queue(void) {
	return _dispatch_queue_get_current() ?: _dispatch_get_root_queue(0, true);
}

static inline dispatch_queue_t _dispatch_queue_get_current(void) {
	return _dispatch_thread_getspecific(dispatch_queue_key);
}

我们获取当前运行队列的时候是通过TSD(Thread-Specific-Data)来获取的, 如果没有当前队列, 则会通过_dispatch_get_root_queue 这个方法获取取一个优先级为DISPATCH_QUEUE_PRIORITY_DEFAULT的队列

dispatch _get _main _queue

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dispatch_queue_t dispatch_get_main_queue(void) {
	return &_dispatch_main_q;
}

struct dispatch_queue_s _dispatch_main_q = {
	.do_vtable = &_dispatch_queue_vtable,
	.do_ref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
	.do_xref_cnt = DISPATCH_OBJECT_GLOBAL_REFCNT,
	.do_suspend_cnt = DISPATCH_OBJECT_SUSPEND_LOCK,
	.do_targetq = &_dispatch_root_queues[DISPATCH_ROOT_QUEUE_COUNT / 2],

	.dq_label = "com.apple.main-thread",
	.dq_running = 1,
	.dq_width = 1,
	.dq_serialnum = 1,
};

获取主队列, dq_width 等于1表示是一个串行队列, 支持overcommit, 且优先级为Default

讲了这么多GCD的源码, 现在来说一下会常用到的API:

dispatch_source

我们常用来实现定时器, 但是它跟NSTimer有什么区别呢？
首相NSTimer依赖于runloop, 由于runloop需要处理很多任务，导致NSTimer的精度降低. 如果忘了停止, 还会造成循环引用. dispatch_source_t是由系统触发,所以精度很高, 下面是通过dispatch_source_t 创建一个计时器.

我们可以通过dispatch_source_t dispatch_source_create(dispatch_source_type_t type,uintptr_t handle,unsigned long mask,dispatch_queue_t _Nullable queue); 创建一个timer, 第一个参数是设置源的类型, 第二个参数可以理解为句柄、索引或id,假如要监听进程，需要传入进程的ID, 第三个参数可以理解为描述, 提供更详细的描述, 让它知道具体要监听啥, 第四个参数就是一个队列, 用来处理所有的响应.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

  _timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
  
  dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC);        //开始时间

  uint64_t interval = 1.0 * NSEC_PER_SEC;     //间隔时间

  dispatch_source_set_timer(_timer, start, interval, 0);

  dispatch_source_set_event_handler(_timer, ^{    // 设置响应dispatch源事件的block

      NSLog(@"------do something------");
  });

  //启动
  dispatch_resume(_timer);
  
  // 如果需要停止
  dispatch_source_cancel(_timer);           	 
  dispatch_release(_timer);

取消dispatch source是一个异步操作，即虽然在调用了dispatch_source_cancel函数之后,dispatch source不能再接收到任何事件,但它还可以继续处理在队列中的事件,直到在队列中的最后一个事件被执行完成后,dispatch source才会执行cancellation handler句柄. 一般情况下是取消了dispatch source后，立即释放掉该对象.

dispatch _suspend / dispatch _resume

dispatch_suspend 可以挂起我们正在执行的队列, 追加到Dispatch Queue中但尚未执行的处理在此之后停止执行, 需要注意的地方是, 这个方法并不会立即暂停正在运行的block,而是在当前block执行完成后,暂停后续的block执行.

dispatch _resume则是唤醒已经挂起的que

dispatch_apply

void dispatch_apply(size_t iterations, dispatch_queue_t queue, void (^block)(size_t))
这个方法提交一个block块到一个分发的队里,以供多次调用.第一个参数是指需要执行的次数, 第二个参数是执行的队列(假设队列是并发队列,则会并发执行block任务,GCD会帮我们管理并发, 不会造成线程爆炸), 第三个参数则是需要执行的block.

dispatch_apply是一个同步调用, 需要block任务全部执行完后才返回.

dispatch_benchmark

uint64_t dispatch_benchmark(size_t count, void (^block)(void));

这个函数可以帮助我们测量计算n次block任务的时间, 也就是说可以直接返回一个时间, 相比于其他的CFAbsoluteTimeGetCurrent 相减, 方便很多.

dispatch_semaphore

这个也就是我们经常说的信号量了,信号量其实就是一个资源计数器,对信号量有两个操作来达到互斥, 分别是P和V操作, 设信号量值为1,当一个进程1运行时, 使用资源, 进行其进行P操作, 对信号量值减1, 也就是资源数少了1个. 这时信号量值为0, 系统中规定当信号量值为0时, 必须等待, 信号量值不为零才能继续操作. 这时如果进程2想要运行, 那么也必须进行P操作, 但是此时信号量为0, 所以无法减1, 即不能P操作, 也就阻塞. 这样就达到了进程1排他访问. 当进程1运行结束后, 释放资源, 进行V操作, 资源数重新加1, 这是信号量的值变为1. 这时进程2发现资源数不为0, 信号量能进行P操作了, 立即执行P操作. 信号量值又变为0. 进程2达到了排他访问.

所以我们可以通过信号量来达到线程同步的问题.

我们可以通过dispatch_semaphore_t dispatch_semaphore_create(long value)来创建一个信号量

long dispatch_semaphore_wait(dispatch_semaphore_t dsema, dispatch_time_t timeout) 等待信号

long dispatch_semaphore_signal(dispatch_semaphore_t dsema) 使用这个函数来发送一个信号

dispatch _group _enter / dispatch _group _leave

dispatch_group_enter : 告诉group, 下面的任务马上要放到group中执行了.

dispatch_group_leave : 告诉group, 任务执行完了, 该任务要从group中移除了.

dispatch_group_wait : 会阻塞当前线程(所以不能放在主线程调用)一直等待; 当group上任务完成,或者等待时间超过设置的超时时间会结束等待.

需要注意的是前两个函数必须成对使用, 否则则会永远等待.

dispatch_group_notify 通常我们应该使用这个, 不会阻塞当前线程，马上返回.

总结

由于工作比较忙, 也都是在空闲时间看的源码, 陆陆续续写了一个星期, 虽然有些地方理解的不是很好, 但是收获却不少, 作为学习的笔记记录了下来.

本文作者： Aeron_Xie
最后更新： 2023年03月25日 22:39:55
本文链接： http://aeronxie.github.io/post/7563b745.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可，转载请注明出处！

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

    			  jsonContent:
				meta: false
				pages: false
				posts:
				  title: true
				  date: true
				  path: true
				  text: false
				  raw: false
				  content: false
				  slug: false
				  updated: false
				  comments: false
				  link: false
				  permalink: false
				  excerpt: false
				  categories: false
				  tags: true


喜欢各种新鲜事物，会 Android \ Swift \ Python \ Java \ C \ Javascript \ Objective-C 单词的拼写~~~~