一、简单介绍

上一篇介绍了dispatch_semaphore的实现原理，这一篇将会对dispatch_group进行源码探究，有了上一篇的基础，这一篇很好理解。主要的函数也就那么几个

// 定义dispatch_group_t结构体
DISPATCH_DECL(dispatch_group)
// 创建
dispatch_group_t dispatch_group_create(void);
// 异步执行分组中的任务
void dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);
// 异步执行分组中的任务真正实现
void dispatch_group_async_f(dispatch_group_t group, dispatch_queue_t queue, void *context, dispatch_function_t work)
// 同步等待，直到与一个组中的所有块都已完成或直到指定的超时结束。
long dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
// 组中的任务全部完成时，回调函数进行通知
void dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);
// 通知真正实现
void dispatch_group_notify_f(dispatch_group_t group, dispatch_queue_t queue, void *context, dispatch_function_t work);
// 标记一个任务进入到组中
void dispatch_group_enter(dispatch_group_t group);
// 标记组中的一个块已完成
void dispatch_group_leave(dispatch_group_t group);

二、实现

实现文件在上一篇介绍的信号量实现文件semaphore.c中以及queue.c实现文件中

1、创建组

dispatch_group_t dispatch_group_create(void)
{
    return (dispatch_group_t)dispatch_semaphore_create(LONG_MAX);
}

看到这个，惊不惊喜，意不意外！dispatch_group_create其实是对dispatch_semaphore_create的封装，可以理解成一个数目极大的信号量，理论上的可用于并行的线程数是不受限制的。

2、标记一个任务进入到组中

void dispatch_group_enter(dispatch_group_t dg) {
    dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
    (void)dispatch_semaphore_wait(dsema, DISPATCH_TIME_FOREVER);
}

这个方法也没做什么，就是调用 wait 方法让信号量的 value 减一而已

3、异步执行分组中的任务

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);
}
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);
    
    // 信号量减1
    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;

    // 全局并发队列，执行_dispatch_async_f2函数
    if (dq->dq_width != 1 && dq->do_targetq) {
        return _dispatch_async_f2(dq, dc);
    }

    // 串行队列直接将任务加到队列中
    _dispatch_queue_push(dq, dc);
}

直接看注释就可以，没什么可说的

4、同步等待，直到与一个组中的所有块都已完成或直到指定的超时结束

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

这个方法用于等待一个组中的所有块都已完成或直到指定的超时结束，可以理解为信号量wait的封装。
如果当前信号量和原始信号量相同，表明任务已经全部完成，直接返回0，如果timeout 为0也会立刻返回，否则调用 _dispatch_group_wait_slow。这个方法同dispatch_semaphore_wait函数中的_dispatch_semaphore_signal_slow几乎一致，区别在于等待结束后它不是return，而是调用 _dispatch_group_wake去唤醒这个 group。

5、组中的任务全部完成时，回调函数进行通知

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);
}
// 真正的实现
void dispatch_group_notify_f(dispatch_group_t dg, dispatch_queue_t dq, void *ctxt,
        void (*func)(void *))
{
    // 在链表的尾部接上新的节点，notify方法并没有做过多的处理，只是是用链表把所有回调通知保存起来，等待调用
    dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;
    struct dispatch_sema_notify_s *dsn, *prev;

    // 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);

    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) {
            _dispatch_group_wake(dsema);
        }
    }
}

这个函数的作用就是：在链表的尾部接上新的节点，notify方法并没有做过多的处理，只是是用链表把所有回调通知保存起来，等待调用

6、标记组中的一个块已完成

void dispatch_group_leave(dispatch_group_t dg)
{
    dispatch_semaphore_t dsema = (dispatch_semaphore_t)dg;

    // 原子加函数
    long value = dispatch_atomic_inc2o(dsema, dsema_value);
    if (slowpath(value == LONG_MIN)) {
        DISPATCH_CLIENT_CRASH("Unbalanced call to dispatch_group_leave()");
    }
    if (slowpath(value == dsema->dsema_orig)) {
        (void)_dispatch_group_wake(dsema);
    }
}

当 group的信号量变为初始值时，表示所有任务都已执行完，开始调用_dispatch_group_wake处理回调。

7、内部唤醒方法

static long _dispatch_group_wake(dispatch_semaphore_t dsema)
{
    // 循环调用signal函数,唤醒当初等待group的信号量
    struct dispatch_sema_notify_s *next, *head, *tail = NULL;
    long rval;

    head = dispatch_atomic_xchg2o(dsema, dsema_notify_head, NULL);
    if (head) {
        // snapshot before anything is notified/woken <rdar://problem/8554546>
        tail = dispatch_atomic_xchg2o(dsema, dsema_notify_tail, NULL);
    }
    rval = dispatch_atomic_xchg2o(dsema, dsema_group_waiters, 0);
    if (rval) {
        _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);
    }
    
    // 获取链表遍历,依次调用dispatch_async_f异步执行在notify函数中注册的回调
    if (head) {
        // async group notify blocks
        do {
            dispatch_async_f(head->dsn_queue, head->dsn_ctxt, head->dsn_func);
            _dispatch_release(head->dsn_queue);
            next = head->dsn_next;
            if (!next && head != tail) {
                while (!(next = head->dsn_next)) {
                    _dispatch_hardware_pause();
                }
            }
            free(head);
        } while ((head = next));
        _dispatch_release(dsema);
    }
    return 0;
}

大致上介绍完了，更多的细节需要穿插着其他篇幅来看才能明确函数的真正实现。
下一篇将真正的领略dispatch核心文件：串行、并行执行任务。

GCD之dispatch_group源码剖析