// 自定义并发队列

    dispatch_queue_t queue = dispatch_queue_create("superman", DISPATCH_QUEUE_CONCURRENT);





    // 创建组

    dispatch_group_t group = dispatch_group_create();





    // 添加任务

    for (int i = 0; i < 5; i++) {





        dispatch_group_async(group, queue, ^{

            NSLog(@"开始执行任务 -- %d", i);





            sleep(2);

            NSLog(@"任务-%d执行完毕", i);

        });





    }





    // 添加任务

    for (int i = 0; i < 3; i++) {





        dispatch_group_enter(group);

        dispatch_async(queue, ^{

            NSLog(@"开始执行终极任务 -- %d", i);





            sleep(1);

            NSLog(@"终极任务-%d执行完毕", i);





            dispatch_group_leave(group);

        });

    }





    // 任务执行完毕回调

    dispatch_group_notify(group, queue, ^{





        NSLog(@"任务都执行完了哦");





    });

dispatch_group_tdispatch_group_create(void){  return _dispatch_group_create_with_count(0);}

static inline dispatch_group_t

_dispatch_group_create_with_count(uint32_t n)

{

  dispatch_group_t dg = _dispatch_object_alloc(DISPATCH_VTABLE(group),

      sizeof(struct dispatch_group_s));

  dg->do_next = DISPATCH_OBJECT_LISTLESS;

  dg->do_targetq = _dispatch_get_default_queue(false);

  if (n) {

    os_atomic_store2o(dg, dg_bits,

        (uint32_t)-n * DISPATCH_GROUP_VALUE_INTERVAL, relaxed);

    os_atomic_store2o(dg, do_ref_cnt, 1, relaxed); // <rdar://22318411>

  }

  return dg;

}





...





#define os_atomic_store2o(p, f, v, m) \

os_atomic_store(&(p)->f, (v), m)





...





#define os_atomic_store(p, v, m) \

atomic_store_explicit(_os_atomic_c11_atomic(p), v, memory_order_##m)

...





#define atomic_store_explicit __c11_atomic_store





-------





在头文件<stdatomic.h>中定义                                                     

| --------------------------------------------------------------------------- 

| void atomic_store（volatile A * obj，需要C）;                                 





原子替换`obj`指向的原子变量的值`desired`。该操作是原子写入操作。





------

voiddispatch_group_enter(dispatch_group_t dg){  // The value is decremented on a 32bits wide atomic so that the carry  // for the 0 -> -1 transition is not propagated to the upper 32bits.  uint32_t old_bits = os_atomic_sub_orig2o(dg, dg_bits,      DISPATCH_GROUP_VALUE_INTERVAL, acquire);  uint32_t old_value = old_bits & DISPATCH_GROUP_VALUE_MASK;  if (unlikely(old_value == 0)) {    _dispatch_retain(dg); // <rdar://problem/22318411>  }  if (unlikely(old_value == DISPATCH_GROUP_VALUE_MAX)) {    DISPATCH_CLIENT_CRASH(old_bits,        "Too many nested calls to dispatch_group_enter()");  }}

void

dispatch_group_leave(dispatch_group_t dg)

{

  // 该值在64位宽的原子上递增

  // the -1 -> 0 转换以原子的方式递增生成

  uint64_t new_state, old_state = os_atomic_add_orig2o(dg, dg_state,

      DISPATCH_GROUP_VALUE_INTERVAL, release);

  uint32_t old_value = (uint32_t)(old_state & DISPATCH_GROUP_VALUE_MASK);





  if (unlikely(old_value == DISPATCH_GROUP_VALUE_1)) {

    old_state += DISPATCH_GROUP_VALUE_INTERVAL;

    do {

      new_state = old_state;

      if ((old_state & DISPATCH_GROUP_VALUE_MASK) == 0) {

        new_state &= ~DISPATCH_GROUP_HAS_WAITERS;

        new_state &= ~DISPATCH_GROUP_HAS_NOTIFS;

      } else {

        // If the group was entered again since the atomic_add above,

        // we can't clear the waiters bit anymore as we don't know for

        // which generation the waiters are for

        new_state &= ~DISPATCH_GROUP_HAS_NOTIFS;

      }

      if (old_state == new_state) break;

    } while (unlikely(!os_atomic_cmpxchgv2o(dg, dg_state,

        old_state, new_state, &old_state, relaxed)));





                // 唤醒的是 notify

    return _dispatch_group_wake(dg, old_state, true);

  }





  if (unlikely(old_value == 0)) {

    DISPATCH_CLIENT_CRASH((uintptr_t)old_value,

        "Unbalanced call to dispatch_group_leave()");

  }

}





...





#define DISPATCH_GROUP_GEN_MASK         0xffffffff00000000ULL

#define DISPATCH_GROUP_VALUE_MASK       0x00000000fffffffcULL

#define DISPATCH_GROUP_VALUE_INTERVAL   0x0000000000000004ULL

#define DISPATCH_GROUP_VALUE_1          DISPATCH_GROUP_VALUE_MASK

#define DISPATCH_GROUP_VALUE_MAX        DISPATCH_GROUP_VALUE_INTERVAL

#define DISPATCH_GROUP_HAS_NOTIFS       0x0000000000000002ULL

#define DISPATCH_GROUP_HAS_WAITERS      0x0000000000000001ULL

void


dispatch_group_async
(
dispatch_group_t dg, 
dispatch_queue_t dq,

    
dispatch_block_t db)

{

  
dispatch_continuation_t dc = _dispatch_continuation_alloc();

  
uintptr_t dc_flags = DC_FLAG_CONSUME | DC_FLAG_GROUP_ASYNC;

  
dispatch_qos_t qos;





  qos = _dispatch_continuation_init(dc, dq, db, 
0, dc_flags);

  _dispatch_continuation_group_async(dg, dq, dc, qos);

}

static inline void_dispatch_continuation_group_async(dispatch_group_t dg, dispatch_queue_t dq,    dispatch_continuation_t dc, dispatch_qos_t qos){  dispatch_group_enter(dg);  dc->dc_data = dg;  _dispatch_continuation_async(dq, dc, qos, dc->dc_flags);}

static inline void_dispatch_continuation_with_group_invoke(dispatch_continuation_t dc){  struct dispatch_object_s *dou = dc->dc_data;  unsigned long type = dx_type(dou);  if (type == DISPATCH_GROUP_TYPE) {    _dispatch_client_callout(dc->dc_ctxt, dc->dc_func);    _dispatch_trace_item_complete(dc);    dispatch_group_leave((dispatch_group_t)dou);  } else {    DISPATCH_INTERNAL_CRASH(dx_type(dou), "Unexpected object type");  }}