// 调度组 － 监听一组任务统一完成之后，执行某一个操作

- (void)viewDidLoad {
    [super viewDidLoad];
    
    [self group2];
}


- (void)group2 {
    
    // 1. 创建 group
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    
    // 2. 创建并发任务
    dispatch_group_enter(group);
    dispatch_async(q, ^{
        [NSThread sleepForTimeInterval:1.0];
        NSLog(@"AAA - %@", [NSThread currentThread]);
        
        dispatch_group_leave(group);
    });
    dispatch_group_enter(group);
    dispatch_async(q, ^{
        [NSThread sleepForTimeInterval:0.5];
        NSLog(@"BBB - %@", [NSThread currentThread]);
        
        dispatch_group_leave(group);
    });
    // 3. 监听调度组
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"over");
    });
}


- (void)group1 {
    
    // 1. 创建 group
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    
    // 2. 创建并发任务
    dispatch_group_async(group, q, ^{
        [NSThread sleepForTimeInterval:1.0];
        NSLog(@"AAA - %@", [NSThread currentThread]);
    });
    dispatch_group_async(group, q, ^{
        NSLog(@"BBB - %@", [NSThread currentThread]);
    });
    
    // 3. 统一获取通知
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"over");
    });
}


@end

在中端中查看  

man dispatch_group_enter

NAME

     dispatch_group_create, dispatch_group_async, dispatch_group_wait,

     dispatch_group_notify -- group blocks submitted to queues

SYNOPSIS

     #include <dispatch/dispatch.h>

     dispatch_group_t

     dispatch_group_create(void);

     void

     dispatch_group_enter(dispatch_group_t group);

     void

     dispatch_group_leave(dispatch_group_t group);

     long

     dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);

    void

     dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue,

         void (^block)(void));

     void

     dispatch_group_notify_f(dispatch_group_t group, dispatch_queue_t queue,

         void *context, void (*function)(void *));

     void

     dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue,

         void (^block)(void));

     void

     dispatch_group_async_f(dispatch_group_t group, dispatch_queue_t queue,

         void *context, void (*function)(void *));

DESCRIPTION

     A dispatch group is an association of one or more blocks submitted to

     dispatch queues for asynchronous invocation.  Applications may use dis-

     patch groups to wait for the completion of blocks associated with the

     group.

     The dispatch_group_create() function returns a new and empty dispatch

     group.

     The dispatch_group_enter() and dispatch_group_leave() functions update

     the number of blocks running within a group.

     The dispatch_group_wait() function waits until all blocks associated with

     the group have completed, or until the specified timeout has elapsed.  If

     the group becomes empty within the specified amount of time, the function

     will return zero indicating success. Otherwise, a non-zero return code

     will be returned.  When DISPATCH_TIME_FOREVER is passed as the timeout,

     calls to this function will wait an unlimited amount of time until the

     group becomes empty and the return value is always zero.

     The dispatch_group_notify() function provides asynchronous notification

     of the completion of the blocks associated with the group by submitting

     the block to the specified queue once all blocks associated with the

     group have completed.  The system holds a reference to the dispatch group

     while an asynchronous notification is pending, therefore it is valid to

     release the group after setting a notification block.  The group will be

     empty at the time the notification block is submitted to the target

     queue. The group may either be released with dispatch_release() or reused

     for additional operations.

     The dispatch_group_async() convenience function behaves like so:

     void

     dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block)

     {

             dispatch_retain(group);

             dispatch_group_enter(group);

             dispatch_async(queue, ^{

                     block();

                     dispatch_group_leave(group);

                     dispatch_release(group);

           });

     }