之前已經(jīng)介紹了dispatch_semaphore的底層實(shí)現(xiàn)固蛾，dispatch_group的實(shí)現(xiàn)是基于前者的。在看源碼之前悲酷，我們先看一下我們是如何應(yīng)用的最易。假設(shè)有這么場景：有一個A耗時(shí)操作，B和C兩個網(wǎng)絡(luò)請求和一個耗時(shí)操作C當(dāng)ABC都執(zhí)行完成后借嗽，刷新頁面琳轿。我們可以用dispatch_group實(shí)現(xiàn)判沟。關(guān)鍵如下：
- (void)viewDidLoad {
[super viewDidLoad];
__block NSInteger number = 0;
dispatch_group_t group = dispatch_group_create();
//A耗時(shí)操作
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
sleep(3);
number += 2222;
});
//B網(wǎng)絡(luò)請求
dispatch_group_enter(group);
[self sendRequestWithCompletion:^(id response) {
number += [response integerValue];
dispatch_group_leave(group);
}];
//C網(wǎng)絡(luò)請求
dispatch_group_enter(group);
[self sendRequestWithCompletion:^(id response) {
number += [response integerValue];
dispatch_group_leave(group);
}];
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"%zd", number);
});
}
- (void)sendRequestWithCompletion:(void (^)(id response))completion {
//模擬一個網(wǎng)絡(luò)請求
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
sleep(2);
dispatch_async(dispatch_get_main_queue(), ^{
if (completion) completion(@1111);
});
});
}
接下來我們根據(jù)上面的流程來看一下dispatch_group的相關(guān)API
dispatch_group_create
dispatch_group_t
dispatch_group_create(void)
{
return (dispatch_group_t)dispatch_semaphore_create(LONG_MAX);
}
dispatch_group_create其實(shí)就是創(chuàng)建了一個value為LONG_MAX的dispatch_semaphore信號量
dispatch_group_async
void
dispatch_group_async(dispatch_group_t dg, dispatch_queue_t dq,
dispatch_block_t db)
{
dispatch_group_async_f(dg, dq, _dispatch_Block_copy(db),
_dispatch_call_block_and_release);
}
dispatch_group_async只是dispatch_group_async_f的封裝
dispatch_group_async_f
void
dispatch_group_async_f(dispatch_group_t dg, dispatch_queue_t dq, void *ctxt,
dispatch_function_t func)
{
dispatch_continuation_t dc;
_dispatch_retain(dg);
dispatch_group_enter(dg);
dc = fastpath(_dispatch_continuation_alloc_cacheonly());
if (!dc) {
dc = _dispatch_continuation_alloc_from_heap();
}
dc->do_vtable = (void *)(DISPATCH_OBJ_ASYNC_BIT | DISPATCH_OBJ_GROUP_BIT);
dc->dc_func = func;
dc->dc_ctxt = ctxt;
dc->dc_group = dg;
// No fastpath/slowpath hint because we simply don't know
if (dq->dq_width != 1 && dq->do_targetq) {
return _dispatch_async_f2(dq, dc);
}
_dispatch_queue_push(dq, dc);
}
從上面的代碼我們可以看出dispatch_group_async_f和dispatch_async_f相似耿芹。dispatch_group_async_f多了dispatch_group_enter(dg);，另外在do_vtable的賦值中dispatch_group_async_f多了一個DISPATCH_OBJ_GROUP_BIT的標(biāo)記符挪哄。既然添加了dispatch_group_enter必定會存在dispatch_group_leave吧秕。在之前《深入理解GCD之dispatch_queue》介紹_dispatch_continuation_pop函數(shù)的源碼中有一段代碼如下：
_dispatch_client_callout(dc->dc_ctxt, dc->dc_func);
if (dg) {
//group需要進(jìn)行調(diào)用dispatch_group_leave并釋放信號
dispatch_group_leave(dg);
_dispatch_release(dg);
}
所以dispatch_group_async_f函數(shù)中的dispatch_group_leave是在_dispatch_continuation_pop函數(shù)中調(diào)用的。
這里概括一下dispatch_group_async_f的工作流程：
- 調(diào)用
dispatch_group_enter迹炼； - 將block和queue等信息記錄到
dispatch_continuation_t結(jié)構(gòu)體中砸彬，并將它加入到group的鏈表中； -
_dispatch_continuation_pop執(zhí)行時(shí)會判斷任務(wù)是否為group斯入，是的話執(zhí)行完任務(wù)再調(diào)用dispatch_group_leave以達(dá)到信號量的平衡砂碉。
dispatch_group_enter
void
dispatch_group_enter(dispatch_group_t dg)
{
dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
(void)dispatch_semaphore_wait(dsema, DISPATCH_TIME_FOREVER);
}
dispatch_group_enter將dispatch_group_t轉(zhuǎn)換成dispatch_semaphore_t，并調(diào)用dispatch_semaphore_wait咱扣，原子性減1后绽淘，進(jìn)入等待狀態(tài)直到有信號喚醒涵防。所以說dispatch_group_enter就是對dispatch_semaphore_wait的封裝闹伪。
dispatch_group_leave
void
dispatch_group_leave(dispatch_group_t dg)
{
dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
dispatch_atomic_release_barrier();
long value = dispatch_atomic_inc2o(dsema, dsema_value);//dsema_value原子性加1
if (slowpath(value == LONG_MIN)) {//內(nèi)存溢出，由于dispatch_group_leave在dispatch_group_enter之前調(diào)用
DISPATCH_CLIENT_CRASH("Unbalanced call to dispatch_group_leave()");
}
if (slowpath(value == dsema->dsema_orig)) {//表示所有任務(wù)已經(jīng)完成壮池，喚醒group
(void)_dispatch_group_wake(dsema);
}
}
從上面的源代碼中我們看到dispatch_group_leave將dispatch_group_t轉(zhuǎn)換成dispatch_semaphore_t后將dsema_value的值原子性加1偏瓤。如果value為LONG_MIN程序crash；如果value等于dsema_orig表示所有任務(wù)已完成椰憋，調(diào)用_dispatch_group_wake喚醒group（_dispatch_group_wake的用于和notify有關(guān)厅克，我們會在后面介紹）。因?yàn)樵?code>enter的時(shí)候進(jìn)行了原子性減1操作橙依。所以在leave的時(shí)候需要原子性加1证舟。
這里先說明一下enter和leave之間的關(guān)系：
dispatch_group_leave與dispatch_group_enter配對使用。當(dāng)調(diào)用了
dispatch_group_enter而沒有調(diào)用dispatch_group_leave時(shí)窗骑，由于value不等于dsema_orig不會走到喚醒邏輯女责，dispatch_group_notify中的任務(wù)無法執(zhí)行或者dispatch_group_wait收不到信號而卡住線程。dispatch_group_enter必須在dispatch_group_leave之前出現(xiàn)创译。當(dāng)
dispatch_group_leave比dispatch_group_enter多調(diào)用了一次或者說在dispatch_group_enter之前被調(diào)用的時(shí)候抵知，dispatch_group_leave進(jìn)行原子性加1操作，相當(dāng)于value為LONGMAX+1软族，發(fā)生數(shù)據(jù)長度溢出刷喜，變成LONG_MIN，由于value == LONG_MIN成立立砸，程序發(fā)生crash掖疮。
dispatch_group_notify
void
dispatch_group_notify(dispatch_group_t dg, dispatch_queue_t dq,
dispatch_block_t db)
{
dispatch_group_notify_f(dg, dq, _dispatch_Block_copy(db),
_dispatch_call_block_and_release);
}
dispatch_group_notify是dispatch_group_notify_f的封裝，具體實(shí)現(xiàn)在后者颗祝。
dispatch_group_notify_f
void
dispatch_group_notify_f(dispatch_group_t dg, dispatch_queue_t dq, void *ctxt,
void (*func)(void *))
{
dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
struct dispatch_sema_notify_s *dsn, *prev;
//封裝dispatch_continuation_t結(jié)構(gòu)體
// FIXME -- this should be updated to use the continuation cache
while (!(dsn = calloc(1, sizeof(*dsn)))) {
sleep(1);
}
dsn->dsn_queue = dq;
dsn->dsn_ctxt = ctxt;
dsn->dsn_func = func;
_dispatch_retain(dq);
dispatch_atomic_store_barrier();
//將結(jié)構(gòu)體放到鏈表尾部氮墨，如果鏈表為空同時(shí)設(shè)置鏈表頭部節(jié)點(diǎn)并喚醒group
prev = dispatch_atomic_xchg2o(dsema, dsema_notify_tail, dsn);
if (fastpath(prev)) {
prev->dsn_next = dsn;
} else {
_dispatch_retain(dg);
(void)dispatch_atomic_xchg2o(dsema, dsema_notify_head, dsn);
if (dsema->dsema_value == dsema->dsema_orig) {//任務(wù)已經(jīng)完成纺蛆，喚醒group
_dispatch_group_wake(dsema);
}
}
}
所以dispatch_group_notify函數(shù)只是用鏈表把所有回調(diào)通知保存起來，等待調(diào)用规揪。
_dispatch_group_wake
static long
_dispatch_group_wake(dispatch_semaphore_t dsema)
{
struct dispatch_sema_notify_s *next, *head, *tail = NULL;
long rval;
//將dsema的dsema_notify_head賦值為NULL桥氏，同時(shí)將之前的內(nèi)容賦給head
head = dispatch_atomic_xchg2o(dsema, dsema_notify_head, NULL);
if (head) {
// snapshot before anything is notified/woken <rdar://problem/8554546>
//將dsema的dsema_notify_tail賦值為NULL，同時(shí)將之前的內(nèi)容賦給tail
tail = dispatch_atomic_xchg2o(dsema, dsema_notify_tail, NULL);
}
//將dsema的dsema_group_waiters設(shè)置為0猛铅，并返回原來的值
rval = dispatch_atomic_xchg2o(dsema, dsema_group_waiters, 0);
if (rval) {
//循環(huán)調(diào)用semaphore_signal喚醒當(dāng)初等待group的信號量字支，使得dispatch_group_wait函數(shù)返回。
// wake group waiters
#if USE_MACH_SEM
_dispatch_semaphore_create_port(&dsema->dsema_waiter_port);
do {
kern_return_t kr = semaphore_signal(dsema->dsema_waiter_port);
DISPATCH_SEMAPHORE_VERIFY_KR(kr);
} while (--rval);
#elif USE_POSIX_SEM
do {
int ret = sem_post(&dsema->dsema_sem);
DISPATCH_SEMAPHORE_VERIFY_RET(ret);
} while (--rval);
#endif
}
if (head) {
//獲取鏈表奸忽，依次調(diào)用dispatch_async_f異步執(zhí)行在notify函數(shù)中的任務(wù)即Block堕伪。
// async group notify blocks
do {
dispatch_async_f(head->dsn_queue, head->dsn_ctxt, head->dsn_func);
_dispatch_release(head->dsn_queue);
next = fastpath(head->dsn_next);
if (!next && head != tail) {
while (!(next = fastpath(head->dsn_next))) {
_dispatch_hardware_pause();
}
}
free(head);
} while ((head = next));
_dispatch_release(dsema);
}
return 0;
}
_dispatch_group_wake主要的作用有兩個：
調(diào)用semaphore_signal喚醒當(dāng)初等待group的信號量，使得dispatch_group_wait函數(shù)返回栗菜。
獲取鏈表欠雌，依次調(diào)用dispatch_async_f異步執(zhí)行在notify函數(shù)中的任務(wù)即Block。
到這里我們已經(jīng)差不多知道了dispatch_group工作過程疙筹，我們用一張圖表示：
dispatch_group_wait
long
dispatch_group_wait(dispatch_group_t dg, dispatch_time_t timeout)
{
dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
if (dsema->dsema_value == dsema->dsema_orig) {//沒有需要執(zhí)行的任務(wù)
return 0;
}
if (timeout == 0) {//返回超時(shí)
#if USE_MACH_SEM
return KERN_OPERATION_TIMED_OUT;
#elif USE_POSIX_SEM
errno = ETIMEDOUT;
return (-1);
#endif
}
return _dispatch_group_wait_slow(dsema, timeout);
}
dispatch_group_wait用于等待group中的任務(wù)完成富俄。
_dispatch_group_wait_slow
static long
_dispatch_group_wait_slow(dispatch_semaphore_t dsema, dispatch_time_t timeout)
{
long orig;
again:
// check before we cause another signal to be sent by incrementing
// dsema->dsema_group_waiters
if (dsema->dsema_value == dsema->dsema_orig) {
return _dispatch_group_wake(dsema);
}
// Mach semaphores appear to sometimes spuriously wake up. Therefore,
// we keep a parallel count of the number of times a Mach semaphore is
// signaled (6880961).
(void)dispatch_atomic_inc2o(dsema, dsema_group_waiters);
// check the values again in case we need to wake any threads
if (dsema->dsema_value == dsema->dsema_orig) {
return _dispatch_group_wake(dsema);
}
#if USE_MACH_SEM
mach_timespec_t _timeout;
kern_return_t kr;
_dispatch_semaphore_create_port(&dsema->dsema_waiter_port);
// From xnu/osfmk/kern/sync_sema.c:
// wait_semaphore->count = -1; /* we don't keep an actual count */
//
// The code above does not match the documentation, and that fact is
// not surprising. The documented semantics are clumsy to use in any
// practical way. The above hack effectively tricks the rest of the
// Mach semaphore logic to behave like the libdispatch algorithm.
switch (timeout) {
default:
do {
uint64_t nsec = _dispatch_timeout(timeout);
_timeout.tv_sec = (typeof(_timeout.tv_sec))(nsec / NSEC_PER_SEC);
_timeout.tv_nsec = (typeof(_timeout.tv_nsec))(nsec % NSEC_PER_SEC);
kr = slowpath(semaphore_timedwait(dsema->dsema_waiter_port,
_timeout));
} while (kr == KERN_ABORTED);
if (kr != KERN_OPERATION_TIMED_OUT) {
DISPATCH_SEMAPHORE_VERIFY_KR(kr);
break;
}
// Fall through and try to undo the earlier change to
// dsema->dsema_group_waiters
case DISPATCH_TIME_NOW:
while ((orig = dsema->dsema_group_waiters)) {
if (dispatch_atomic_cmpxchg2o(dsema, dsema_group_waiters, orig,
orig - 1)) {
return KERN_OPERATION_TIMED_OUT;
}
}
// Another thread called semaphore_signal().
// Fall through and drain the wakeup.
case DISPATCH_TIME_FOREVER:
do {
kr = semaphore_wait(dsema->dsema_waiter_port);
} while (kr == KERN_ABORTED);
DISPATCH_SEMAPHORE_VERIFY_KR(kr);
break;
}
#elif USE_POSIX_SEM
//這部分代碼省略
#endif
goto again;
}
從上面的代碼我們發(fā)現(xiàn)_dispatch_group_wait_slow和_dispatch_semaphore_wait_slow的邏輯很接近。都利用mach內(nèi)核的semaphore進(jìn)行信號的發(fā)送而咆。區(qū)別在于_dispatch_semaphore_wait_slow在等待結(jié)束后是return霍比，而_dispatch_group_wait_slow在等待結(jié)束是調(diào)用_dispatch_group_wake去喚醒這個group。
總結(jié)
dispatch_group是一個初始值為LONG_MAX的信號量暴备，group中的任務(wù)完成是判斷其value是否恢復(fù)成初始值悠瞬。dispatch_group_enter和dispatch_group_leave必須成對使用并且支持嵌套。如果
dispatch_group_enter比dispatch_group_leave多涯捻，由于value不等于dsema_orig不會走到喚醒邏輯浅妆，dispatch_group_notify中的任務(wù)無法執(zhí)行或者dispatch_group_wait收不到信號而卡住線程。如果是dispatch_group_leave多障癌，則會引起崩潰凌外。
