iOS队列组

OC

/**
 * 队列组 dispatch_group_notify
 */
- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");

    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步任务 1、任务 2 都执行完毕后，回到主线程执行下边任务
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        NSLog(@"group---end");
    });
}

/**
 * 队列组 dispatch_group_wait
 */
- (void)groupWait {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");

    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
    });

    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    NSLog(@"group---end");

}

/**
 * 队列组 dispatch_group_enter、dispatch_group_leave
 */
- (void)groupEnterAndLeave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"group---begin");

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程

        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程

        dispatch_group_leave(group);
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程.
        [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程

        NSLog(@"group---end");
    });
    //从 dispatch_group_enter、dispatch_group_leave
    //相关代码运行结果中可以看出：当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。
    //这里的dispatch_group_enter、dispatch_group_leave 组合，其实等同于dispatch_group_async。
}

Swift

 //MARK: ---队列组---
    /**
    * 队列组 dispatch_group_notify
    */
    func groupNotify() {
        let queue = DispatchQueue.main
        let group = DispatchGroup.init()
//        group( asyncSerial() )
        queue.async(group: group, execute: {
            //追加任务1
            print("追加任务1")
        })
        
        queue.async(group: group, execute: {
           //追加任务2
            print("追加任务2")
        })
        
        group.notify(queue: DispatchQueue.main) {
            // 等前面的异步任务 1、任务 2 都执行完毕后，回到主线程执行下边任务
            print("任务3")
        }
        
    }
    /**
    * 队列组 dispatch_group_wait
    */
    func groupWait() {
          let group = DispatchGroup.init()
          let queue = DispatchQueue.global()
        
         queue.async(group: group, execute: {
             //追加任务1
             print("追加任务1")
         })
         
         queue.async(group: group, execute: {
            //追加任务2
             print("追加任务2")
         })
         group.wait(timeout: .now()+1)
    }
    
    /**
    * 队列组 dispatch_group_enter、dispatch_group_leave
    */
    func groupEnterAndLeave(){
        let group = DispatchGroup.init()
        let queue = DispatchQueue.global()
        
        group.enter()
        queue.async(group: group, execute: {
            //追加任务1
            print("追加任务1")
            group.leave()
        })
        
        group.enter()
        queue.async(group: group, execute: {
            //追加任务2
            print("追加任务2")
            group.leave()
        })
        
        group.notify(queue: DispatchQueue.main) {
            // 等前面的异步任务 1、任务 2 都执行完毕后，回到主线程执行下边任务
            print("任务3")
        }
    }