概述

dispatch_group可以將GCD的任務(wù)合并到一個(gè)組里來(lái)管理，也可以同時(shí)監(jiān)聽(tīng)組里所有任務(wù)的執(zhí)行情況。主要的API有以下幾個(gè),先看一下Dispatch Group的具體使用。

• dispatch_group_create
• dispatch_group_enter
• dispatch_group_leave
• dispatch_group_wait
• dispatch_group_notify
• dispatch_group_async

使用篇

dispatch_group最多的用法便是用dispatch_group_enter和dispatch_group_leave實(shí)現(xiàn)一組任務(wù)完成的監(jiān)控或回調(diào)，見(jiàn)代碼示例:

- (void)batchRequestConfig {
    dispatch_group_t group = dispatch_group_create();
    NSArray *list = @[@"1",@"2",@"3"];
    [list enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        //標(biāo)記開(kāi)始本次請(qǐng)求
        dispatch_group_enter(group);
        [self fetchConfigurationWithCompletion:^(NSDictionary *dict) {
            //標(biāo)記本次請(qǐng)求完成
            dispatch_group_leave(group);
        }];
    }];
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //所有請(qǐng)求都完成了,執(zhí)行刷新UI等操作
    });
}
- (void)fetchConfigurationWithCompletion:(void(^)(NSDictionary *dict))completion {
    //AFNetworking或其他網(wǎng)絡(luò)請(qǐng)求庫(kù)
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //模擬網(wǎng)絡(luò)請(qǐng)求
        sleep(2);
        !completion ? nil : completion(nil);
    });
}

dispatch_group有兩個(gè)需要注意的地方：
1、dispatch_group_enter必須在dispatch_group_leave之前出現(xiàn)
2、dispatch_group_enter和dispatch_group_leave必須成對(duì)出現(xiàn)

這里先拋出一個(gè)問(wèn)題讓大家思考一下：如果dispatch_group_enter和dispatch_group_leave不成對(duì)出現(xiàn)會(huì)出現(xiàn)什么結(jié)果？具體的結(jié)論會(huì)在下面的原理篇和結(jié)論篇說(shuō)明。

原理篇

dispatch_group_create

Dispatch Group的本質(zhì)是一個(gè)初始value為LONG_MAX的semaphore，通過(guò)信號(hào)量來(lái)實(shí)現(xiàn)一組任務(wù)的管理，代碼如下：

dispatch_group_t dispatch_group_create(void) {
    //申請(qǐng)內(nèi)存空間
    dispatch_group_t dg = (dispatch_group_t)_dispatch_alloc(
            DISPATCH_VTABLE(group), sizeof(struct dispatch_semaphore_s));
    //使用LONG_MAX初始化信號(hào)量結(jié)構(gòu)體
    _dispatch_semaphore_init(LONG_MAX, dg);
    return dg;
}

dispatch_group_enter

void dispatch_group_enter(dispatch_group_t dg) {
    dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
    long value = dispatch_atomic_dec2o(dsema, dsema_value, acquire);
    if (slowpath(value < 0)) {
        DISPATCH_CLIENT_CRASH(
                "Too many nested calls to dispatch_group_enter()");
    }
}

dispatch_group_enter的邏輯是將dispatch_group_t轉(zhuǎn)換成dispatch_semaphore_t后將dsema_value的值減一。

dispatch_group_leave

void dispatch_group_leave(dispatch_group_t dg) {
    dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
    long value = dispatch_atomic_inc2o(dsema, dsema_value, release);
    if (slowpath(value < 0)) {
        DISPATCH_CLIENT_CRASH("Unbalanced call to dispatch_group_leave()");
    }
    if (slowpath(value == LONG_MAX)) {
        (void)_dispatch_group_wake(dsema);
    }
}

dispatch_group_leave的邏輯是將dispatch_group_t轉(zhuǎn)換成dispatch_semaphore_t后將dsema_value的值加一。
當(dāng)value等于LONG_MAX時(shí)表示所有任務(wù)已完成，調(diào)用_dispatch_group_wake喚醒group，因此dispatch_group_leave與dispatch_group_enter需成對(duì)出現(xiàn)。

當(dāng)調(diào)用了dispatch_group_enter而沒(méi)有調(diào)用dispatch_group_leave時(shí)，會(huì)造成value值不等于LONG_MAX而不會(huì)走到喚醒邏輯，dispatch_group_notify函數(shù)的block無(wú)法執(zhí)行或者dispatch_group_wait收不到semaphore_signal信號(hào)而卡住線(xiàn)程。

當(dāng)dispatch_group_leave比dispatch_group_enter多調(diào)用了一次時(shí)，dispatch_semaphore_t的value會(huì)等于LONGMAX+1（2147483647+1）,即long的負(fù)數(shù)最小值LONG_MIN(–2147483648)。因?yàn)榇藭r(shí)value小于0，所以會(huì)出現(xiàn)”Unbalanced call to dispatch_group_leave()”的崩潰，這是一個(gè)特別需要注意的地方。

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 == LONG_MAX) {
        return 0;
    }
    if (timeout == 0) {
        return KERN_OPERATION_TIMED_OUT;
    }
    return _dispatch_group_wait_slow(dsema, timeout);
}

如果當(dāng)前value的值為初始值，表示任務(wù)都已經(jīng)完成，直接返回0，如果timeout為0的話(huà)返回超時(shí)。其余情況會(huì)調(diào)用_dispatch_group_wait_slow方法。

static long _dispatch_group_wait_slow(dispatch_semaphore_t dsema, dispatch_time_t timeout) {
    long orig;
    mach_timespec_t _timeout;
    kern_return_t kr;
again:
    if (dsema->dsema_value == LONG_MAX) {
        return _dispatch_group_wake(dsema);
    }
    (void)dispatch_atomic_inc2o(dsema, dsema_group_waiters, relaxed);
    if (dsema->dsema_value == LONG_MAX) {
        return _dispatch_group_wake(dsema);
    }
    _dispatch_semaphore_create_port(&dsema->dsema_port);
    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_port, _timeout));
        } while (kr == KERN_ABORTED);

        if (kr != KERN_OPERATION_TIMED_OUT) {
            DISPATCH_SEMAPHORE_VERIFY_KR(kr);
            break;
        }
    case DISPATCH_TIME_NOW:
        orig = dsema->dsema_group_waiters;
        while (orig) {
            if (dispatch_atomic_cmpxchgvw2o(dsema, dsema_group_waiters, orig,
                    orig - 1, &orig, relaxed)) {
                return KERN_OPERATION_TIMED_OUT;
            }
        }
    case DISPATCH_TIME_FOREVER:
        do {
            kr = semaphore_wait(dsema->dsema_port);
        } while (kr == KERN_ABORTED);
        DISPATCH_SEMAPHORE_VERIFY_KR(kr);
        break;
    }
    goto again;
 }

可以看到跟dispatch_semaphore的_dispatch_semaphore_wait_slow方法很類(lèi)似，不同點(diǎn)在于等待完之后調(diào)用的again函數(shù)會(huì)調(diào)用_dispatch_group_wake喚醒當(dāng)前group。_dispatch_group_wake的分析見(jiàn)下面的內(nèi)容。

dispatch_group_notify

void dispatch_group_notify(dispatch_group_t dg, dispatch_queue_t dq,
        dispatch_block_t db) {
    //封裝調(diào)用dispatch_group_notify_f函數(shù)
    dispatch_group_notify_f(dg, dq, _dispatch_Block_copy(db),
            _dispatch_call_block_and_release);
}
//真正的入口函數(shù)
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;
    //封裝結(jié)構(gòu)體
    dispatch_continuation_t prev, dsn = _dispatch_continuation_alloc();
    dsn->do_vtable = (void *)DISPATCH_OBJ_ASYNC_BIT;
    dsn->dc_data = dq;
    dsn->dc_ctxt = ctxt;
    dsn->dc_func = func;
    dsn->do_next = NULL;
    _dispatch_retain(dq);
    //將結(jié)構(gòu)體放到鏈表尾部，如果鏈表為空同時(shí)設(shè)置鏈表頭部節(jié)點(diǎn)并喚醒group
    prev = dispatch_atomic_xchg2o(dsema, dsema_notify_tail, dsn, release);
    if (fastpath(prev)) {
        prev->do_next = dsn;
    } else {
        _dispatch_retain(dg);
        dispatch_atomic_store2o(dsema, dsema_notify_head, dsn, seq_cst);
        dispatch_atomic_barrier(seq_cst); // <rdar://problem/11750916>
        if (dispatch_atomic_load2o(dsema, dsema_value, seq_cst) == LONG_MAX) {
            _dispatch_group_wake(dsema);
        }
    }
}

dispatch_group_notify的具體實(shí)現(xiàn)在dispatch_group_notify_f函數(shù)里，邏輯就是將block和queue封裝到dispatch_continuation_t里，并將它加到鏈表的尾部，如果鏈表為空同時(shí)還會(huì)設(shè)置鏈表的頭部節(jié)點(diǎn)。如果dsema_value的值等于初始值，則調(diào)用_dispatch_group_wake執(zhí)行喚醒邏輯。

dispatch_group_wake

static long _dispatch_group_wake(dispatch_semaphore_t dsema) {
    dispatch_continuation_t next, head, tail = NULL, dc;
    long rval;
   //將dsema的dsema_notify_head賦值為NULL，同時(shí)將之前的內(nèi)容賦給head
    head = dispatch_atomic_xchg2o(dsema, dsema_notify_head, NULL, relaxed);
    if (head) {
        //將dsema的dsema_notify_tail賦值為NULL，同時(shí)將之前的內(nèi)容賦給tail
        tail = dispatch_atomic_xchg2o(dsema, dsema_notify_tail, NULL, relaxed);
    }
    rval = (long)dispatch_atomic_xchg2o(dsema, dsema_group_waiters, 0, relaxed);
    if (rval) {
        // wake group waiters
        _dispatch_semaphore_create_port(&dsema->dsema_port);
        do {
            kern_return_t kr = semaphore_signal(dsema->dsema_port);
            DISPATCH_SEMAPHORE_VERIFY_KR(kr);
        } while (--rval);
    }
    if (head) {
        // async group notify blocks
        do {
            next = fastpath(head->do_next);
            if (!next && head != tail) {
                while (!(next = fastpath(head->do_next))) {
                    dispatch_hardware_pause();
                }
            }
            dispatch_queue_t dsn_queue = (dispatch_queue_t)head->dc_data;
            dc = _dispatch_continuation_free_cacheonly(head);
            //執(zhí)行dispatch_group_notify的block，見(jiàn)dispatch_queue的分析
            dispatch_async_f(dsn_queue, head->dc_ctxt, head->dc_func);
            _dispatch_release(dsn_queue);
            if (slowpath(dc)) {
                _dispatch_continuation_free_to_cache_limit(dc);
            }
        } while ((head = next));
        _dispatch_release(dsema);
    }
    return 0;
}

dispatch_group_wake首先會(huì)循環(huán)調(diào)用semaphore_signal喚醒等待group的信號(hào)量，使dispatch_group_wait函數(shù)中等待的線(xiàn)程得以喚醒；然后依次獲取鏈表中的元素并調(diào)用dispatch_async_f異步執(zhí)行dispatch_group_notify函數(shù)中注冊(cè)的回調(diào)，使得notify中的block得以執(zhí)行。

dispatch_group_async

dispatch_group_async的原理和dispatch_async比較類(lèi)似，區(qū)別點(diǎn)在于group操作會(huì)帶上DISPATCH_OBJ_GROUP_BIT標(biāo)志位。添加group任務(wù)時(shí)會(huì)先執(zhí)行dispatch_group_enter，然后在任務(wù)執(zhí)行時(shí)會(huì)對(duì)帶有該標(biāo)記的執(zhí)行dispatch_group_leave操作。下面看下具體實(shí)現(xiàn)：

void dispatch_group_async(dispatch_group_t dg, dispatch_queue_t dq,
        dispatch_block_t db) {
    //封裝調(diào)用dispatch_group_async_f函數(shù)
    dispatch_group_async_f(dg, dq, _dispatch_Block_copy(db),
            _dispatch_call_block_and_release);
}
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);
    //先調(diào)用dispatch_group_enter操作
    dispatch_group_enter(dg);
    dc = _dispatch_continuation_alloc();
    //DISPATCH_OBJ_GROUP_BIT會(huì)在_dispatch_continuation_pop方法中用來(lái)判斷是否為group，如果為group會(huì)執(zhí)行dispatch_group_leave
    dc->do_vtable = (void *)(DISPATCH_OBJ_ASYNC_BIT | DISPATCH_OBJ_GROUP_BIT);
    dc->dc_func = func;
    dc->dc_ctxt = ctxt;
    dc->dc_data = dg;
    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代碼類(lèi)似，主要執(zhí)行了以下操作：
1、調(diào)用dispatch_group_enter
2、將block和queue等信息記錄到dispatch_continuation_t中，并將它加入到group的鏈表中。
3、_dispatch_continuation_pop執(zhí)行時(shí)會(huì)判斷任務(wù)是否為group，是的話(huà)執(zhí)行完任務(wù)再調(diào)用dispatch_group_leave以達(dá)到信號(hào)量value的平衡。

_dispatch_continuation_pop簡(jiǎn)化后的代碼如下：

static inline void _dispatch_continuation_pop(dispatch_object_t dou) {
    dispatch_continuation_t dc = dou._dc, dc1;
    dispatch_group_t dg;
    _dispatch_trace_continuation_pop(_dispatch_queue_get_current(), dou);
    //判斷是否為隊(duì)列，是的話(huà)執(zhí)行隊(duì)列的invoke函數(shù)
    if (DISPATCH_OBJ_IS_VTABLE(dou._do)) {
        return dx_invoke(dou._do);
    } 
    //dispatch_continuation_t結(jié)構(gòu)體，執(zhí)行具體任務(wù)
    if ((long)dc->do_vtable & DISPATCH_OBJ_GROUP_BIT) {
        dg = dc->dc_data;
    } else {
        dg = NULL;
    }
    _dispatch_client_callout(dc->dc_ctxt, dc->dc_func);
    if (dg) {
       //這是group操作，執(zhí)行l(wèi)eave操作對(duì)應(yīng)最初的enter
        dispatch_group_leave(dg);
        _dispatch_release(dg);
    }
}

總結(jié)篇

dispatch_group本質(zhì)是個(gè)初始值為L(zhǎng)ONG_MAX的信號(hào)量，等待group中的任務(wù)完成其實(shí)是等待value恢復(fù)初始值。
dispatch_group_enter和dispatch_group_leave必須成對(duì)出現(xiàn)。

如果dispatch_group_enter比dispatch_group_leave多一次，則wait函數(shù)等待的
線(xiàn)程不會(huì)被喚醒和注冊(cè)notify的回調(diào)block不會(huì)執(zhí)行；

如果dispatch_group_leave比dispatch_group_enter多一次，則會(huì)引起崩潰。