DispatchGroup

最新推荐文章于 2020-11-05 14:41:19 发布
最新推荐文章于 2020-11-05 14:41:19 发布
阅读量312 收藏
点赞数
分类专栏： 面试[
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012581760/article/details/106496933
版权

一、DispatchGroup三种用法:

1.notify(依赖任务)
  func testNotify() {
        let group = DispatchGroup()
        let myQueue = DispatchQueue(label: "com.aa")
        myQueue.async(group: group, qos: .default, flags: []) {
            for _ in 0...10 {
                print("耗时任务一")
            }
        }
        myQueue.async(group: group, qos: .default, flags: []){
                   for _ in 0...10 {
                       print("耗时任务二")
                   }
        }
        
        //执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务
           group.notify(queue: myQueue) {
               print("回到该队列中执行")
           }
        
    }

打印结果

耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
回到该队列中执行
2.wait(任务等待)
  func testNotify() {
        let group = DispatchGroup()
        let myQueue = DispatchQueue(label: "com.aa")
        myQueue.async(group: group, qos: .default, flags: []) {
            for _ in 0...10 {
                print("耗时任务一")
            }
        }
        myQueue.async(group: group, qos: .default, flags: []){
                   for _ in 0...10 {
                       print("耗时任务二")
                   }
        }
        
        //执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务
        group.wait(timeout: DispatchTime.distantFuture)
        print("接下来的操作")
        
    }

打印结果

耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
接下来的操作

3.enter leave 手动管理group计数,enter和leave必须配对

    func testNotify() {
        let group = DispatchGroup()
        let myQueue = DispatchQueue(label: "com.aa")
         group.enter()//把该任务添加到组队列中执行
      myQueue.async(group: group, qos: .default, flags: [], execute: {
          for _ in 0...10 {
              print("耗时任务一")
              
          }
        group.leave()//执行完之后从组队列中移除
      })
        group.enter()//把该任务添加到组队列中执行
      myQueue.async(group: group, qos: .default, flags: [], execute: {
               for _ in 0...10 {
                   print("耗时任务二")
                   
               }
            group.leave()//执行完之后从组队列中移除
     })
        
        //执行完上面的两个耗时操作, 回到myQueue队列中执行下一步的任务
        //当上面所有的任务执行完之后通知
       
        print("接下来的操作开始")
       group.notify(queue: .main) {
           print("所有的任务执行完了")
       }
        print("接下来的操作结束")
        
    }

打印结果

接下来的操作开始
接下来的操作结束
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务一
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
耗时任务二
所有的任务执行完了
Notify与wait的区别
   func testNotify2() {
        print("开始设置任务")
        DispatchQueue.main.async {
            let group  = DispatchGroup()
            let taskQueue = DispatchQueue(label: "ccc")
            for i in 0..<3 {
                group.enter()
                taskQueue.async {
                    print("开始第\(i)项任务")
                    sleep(UInt32(1))
                    print("结束第\(i)项任务")
                    group.leave()
                }
            }
            
            group.notify(queue: taskQueue) {
                print("全部执行完毕")
            }
          
        }
        
    }

   func testNotify2() {
        print("开始设置任务")
        DispatchQueue.main.async {
            let group  = DispatchGroup()
            let taskQueue = DispatchQueue(label: "ccc")
            for i in 0..<3 {
                group.enter()
                taskQueue.async {
                    print("开始第\(i)项任务")
                    sleep(UInt32(1))
                    print("结束第\(i)项任务")
                    group.leave()
                }
            }
            
            let result = group.wait(timeout: DispatchTime(uptimeNanoseconds: 1))
            if result == .success {
                print("全部任务完成")
            }else{
                print("任务超时")
            }
          
        }
        print("结束了么")
        
    }

打印结果

开始设置任务
结束了么
容器
任务超时
开始第0项任务
结束第0项任务
开始第1项任务
结束第1项任务
开始第2项任务
结束第2项任务

 func testNotify2() {
        print("开始设置任务")
        DispatchQueue.main.async {
            let group  = DispatchGroup()
            let taskQueue = DispatchQueue(label: "ccc")
            for i in 0..<3 {
                group.enter()
                taskQueue.async {
                    print("开始第\(i)项任务")
                    sleep(UInt32(1))
                    print("结束第\(i)项任务")
                    group.leave()
                }
            }
            
            let result = group.wait(timeout: DispatchTime.distantFuture)
            if result == .success {
                print("全部任务完成")
            }else{
                print("任务超时")
            }
          
        }
        print("结束了么")
        
    }

打印结果

开始设置任务
结束了么
容器
开始第0项任务
结束第0项任务
开始第1项任务
结束第1项任务
开始第2项任务
结束第2项任务
全部任务完成

下载真实图片,串联执行

Swift

  dispatch_queue_t myQuue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);
    dispatch_async(myQuue, ^{
         NSLog(@"开始第 1 个任务。%@", [NSThread currentThread]);
          NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
        NSData *data = [NSData dataWithContentsOfURL:url];
         UIImage *image = [UIImage imageWithData:data];
        
               NSLog(@"结束第 1 个任务。%@", image);
    });
    
    dispatch_async(myQuue, ^{
          NSLog(@"开始第 2 个任务。%@", [NSThread currentThread]);
                     NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                NSData *data = [NSData dataWithContentsOfURL:url];
                 UIImage *image = [UIImage imageWithData:data];
                NSLog(@"结束第 2 个任务。%@",image);
    });
    
    dispatch_async(myQuue, ^{
             NSLog(@"开始第 3 个任务。%@", [NSThread currentThread]);
                            NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                   NSData *data = [NSData dataWithContentsOfURL:url];
                    UIImage *image = [UIImage imageWithData:data];
                   NSLog(@"结束第 3 个任务。%@",image);
       });

2020-06-02 16:00:01.892165+0800 OCTestFirst[9165:258513] 开始第 1 个任务。<NSThread: 0x600000c11100>{number = 3, name = (null)}
2020-06-02 16:00:05.537238+0800 OCTestFirst[9165:258513] 结束第 1 个任务。<UIImage:0x600002b44d80 anonymous {900, 687}>
2020-06-02 16:00:05.537566+0800 OCTestFirst[9165:258513] 开始第 2 个任务。<NSThread: 0x600000c11100>{number = 3, name = (null)}
2020-06-02 16:00:05.971256+0800 OCTestFirst[9165:258513] 结束第 2 个任务。<UIImage:0x600002b54870 anonymous {900, 687}>
2020-06-02 16:00:05.971575+0800 OCTestFirst[9165:258513] 开始第 3 个任务。<NSThread: 0x600000c11100>{number = 3, name = (null)}
2020-06-02 16:00:05.989165+0800 OCTestFirst[9165:258513] 结束第 3 个任务。<UIImage:0x600002b47960 anonymous {900, 687}>

OC的dispatch_group_enter,dispatch_group_leave和notify的应用

   dispatch_queue_t myQuue = dispatch_queue_create("aa", DISPATCH_QUEUE_CONCURRENT);
    dispatch_group_t myGroup = dispatch_group_create();
    
    dispatch_group_async(myGroup, myQuue, ^{
         dispatch_group_enter(myGroup);
                NSLog(@"开始第 1 个任务。%@", [NSThread currentThread]);
                 NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
               NSData *data = [NSData dataWithContentsOfURL:url];
                UIImage *image = [UIImage imageWithData:data];
               
                      NSLog(@"结束第 1 个任务。%@", image);
        dispatch_group_leave(myGroup);
    });
    
  
    dispatch_group_async(myGroup, myQuue, ^{
         dispatch_group_enter(myGroup);
                 NSLog(@"开始第 2 个任务。%@", [NSThread currentThread]);
                            NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                       NSData *data = [NSData dataWithContentsOfURL:url];
                        UIImage *image = [UIImage imageWithData:data];
                       NSLog(@"结束第 2 个任务。%@",image);
                dispatch_group_leave(myGroup);
    });
    
    dispatch_group_async(myGroup, myQuue, ^{
        dispatch_group_enter(myGroup);
            NSLog(@"开始第 3 个任务。%@", [NSThread currentThread]);
                           NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                  NSData *data = [NSData dataWithContentsOfURL:url];
                   UIImage *image = [UIImage imageWithData:data];
                  NSLog(@"结束第 3 个任务。%@",image);
        dispatch_group_leave(myGroup);
    });
  
    

    dispatch_group_notify(myGroup, myQuue, ^{
        NSLog(@"将要执行");
    });

打印结果

2020-06-02 16:16:41.128073+0800 OCTestFirst[9467:270577] 开始第 1 个任务。<NSThread: 0x600003928080>{number = 2, name = (null)}
2020-06-02 16:16:41.128031+0800 OCTestFirst[9467:270574] 开始第 2 个任务。<NSThread: 0x600003939fc0>{number = 3, name = (null)}
2020-06-02 16:16:41.128144+0800 OCTestFirst[9467:270578] 开始第 3 个任务。<NSThread: 0x60000393a180>{number = 4, name = (null)}
2020-06-02 16:16:43.365683+0800 OCTestFirst[9467:270574] 结束第 2 个任务。<UIImage:0x600001e71050 anonymous {900, 687}>
2020-06-02 16:16:43.365691+0800 OCTestFirst[9467:270577] 结束第 1 个任务。<UIImage:0x600001e72370 anonymous {900, 687}>
2020-06-02 16:16:43.365707+0800 OCTestFirst[9467:270578] 结束第 3 个任务。<UIImage:0x600001e7db00 anonymous {900, 687}>
2020-06-02 16:16:43.366060+0800 OCTestFirst[9467:270577] 将要执行
dispatch_barrier_Async
       
 
    dispatch_queue_t myQuue = dispatch_queue_create("mmm", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(myQuue, ^{
        NSLog(@"开始第 1 个任务。%@", [NSThread currentThread]);
                     NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                   NSData *data = [NSData dataWithContentsOfURL:url];
                    UIImage *image = [UIImage imageWithData:data];
        NSLog(@"结束第 1 个任务。%@", [NSThread currentThread]);
    });
    
    dispatch_async(myQuue, ^{
         NSLog(@"开始第 2 个任务。%@", [NSThread currentThread]);
                        NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                      NSData *data = [NSData dataWithContentsOfURL:url];
                       UIImage *image = [UIImage imageWithData:data];
           NSLog(@"结束第 2 个任务。%@", [NSThread currentThread]);
       });
  
    dispatch_barrier_async(myQuue, ^{
        NSLog(@"中间执行的过程");
    });
    dispatch_async(myQuue, ^{
            NSLog(@"开始第 3 个任务。%@", [NSThread currentThread]);
                         NSURL *url = [NSURL URLWithString:@"http://www.xinhuanet.com/photo/2018-03/13/1122528717_15209051820841n.jpg"];
                       NSData *data = [NSData dataWithContentsOfURL:url];
                        UIImage *image = [UIImage imageWithData:data];
            NSLog(@"结束第 3 个任务。%@", [NSThread currentThread]);
          });

打印结果

2020-06-02 16:32:41.380768+0800 OCTestFirst[9742:282073] 开始第 1 个任务。<NSThread: 0x6000030842c0>{number = 2, name = (null)}
2020-06-02 16:32:41.381077+0800 OCTestFirst[9742:282077] 开始第 2 个任务。<NSThread: 0x600003095100>{number = 4, name = (null)}
2020-06-02 16:32:44.191922+0800 OCTestFirst[9742:282077] 结束第 2 个任务。<NSThread: 0x600003095100>{number = 4, name = (null)}
2020-06-02 16:32:44.212357+0800 OCTestFirst[9742:282073] 结束第 1 个任务。<NSThread: 0x6000030842c0>{number = 2, name = (null)}
2020-06-02 16:32:44.213365+0800 OCTestFirst[9742:282073] 中间执行的过程
2020-06-02 16:32:44.213740+0800 OCTestFirst[9742:282073] 开始第 3 个任务。<NSThread: 0x6000030842c0>{number = 2, name = (null)}
2020-06-02 16:32:44.782746+0800 OCTestFirst[9742:282073] 结束第 3 个任务。<NSThread: 0x6000030842c0>{number = 2, name = (null)}
harkecho
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DispatchGroup合并图片
03-03
用DispatchGroup以及DispatchNotify等加载多张图片然后合并
iOS GCD中级篇 - dispatch_group的理解及使用
weixin_34388207的博客
01-11 116
上一篇GCD基础篇，以及同步、异步，并发、并行几个概率的理解   关于dispatch_group的概念以及几种场景下的使用 1、关于dispatch_group 把一组任务提交到队列中，这些队列可以不相关，然后监听这组任务完成的事件。 最常见的几个方法： 1、dispatch_group_create创建一个调度任务组 2、dispatch_group_async 把一个任务异步提...
完整详解GCD系列（三）dispatch_group
Leo的专栏
11-23 9126
完整详解GCD系列三，详细的阐述了dispatch_group的常用方法，通过实例解析如何使用。并且实例解析了dispatch_group_enter/dispatch_group_leave。提供了三个完整的实例代码
GCD中dispatch_group详解
denggun12345的博客
10-18 1321
平时在进行多线程处理任务时，有时候希望多个任务之间存在着一种联系，希望在所有的任务执行完后做一些总结性处理。 那么就可以将多个任务放在一个任务组中进行统一管理。通过监听组内所有任务执行情况来做相应处理。 常用函数： dispatch_group_create()：创建一个group组。 dispatch_group_async(group, queue, block)：将任务添...
iOS使用dispatch_group实现分组并发网络请求
li198847的博客
12-23 2831
前言 在实际开发中我们通常会遇到这样一种需求：某个页面加载时通过网络请求获得相应的数据，再做某些操作。有时候加载的内容需要通过好几个请求的数据组合而成，比如有两个请求A和B，我们通常为了省事，会将B请求放在A请求成功的回调中发起，在B的成功回调中将数据组合起来，这样做有明显的问题： 请求如果多了，需要写许多嵌套的请求 如果在除了最后一个请求前的某个请求失败了，就不会执行后面的请求，数据...
Dispatch Group机制——笔记
u012773581的博客
02-21 2792
《Effective Objective-C 2.0  编写高质量iOS与OS X代码的52个有效方法》（第四十四条：通过Dispatch Group机制，根据系统资源状况来执行任务）笔记 要点如下： 1、dispatch group是GCD的一项特性，可以把任务分组。这组任务完成后时，调用者会收到通知 据此，可将要并发执行的多个任务合并为一组，这样调用者就可以知道这些任务何时能全部执行完...
Dispatch Group
Shadowsofdeath的专栏
04-06 304
//在追加到Dispatch Queue中的多个处理全部结束后想执行结束处理时： //a.只使用一个Serial Dispatch Queue时,只要将想执行的处理全部追加到该 Serial Dispatch Queue中并在最后追加结束处理,即可实现。 //b.使用Concurrent Dispatch Queue时或同时使用多个Dispatch Queue时,可通过Disp...
dispatch group使用方法详解
richard_如风的专栏
01-31 3490
第一、dispatch group可以用来将多个block组成一组以监测这些Block全部完成或者等待全部完成时发出的消息。使用函数dispatch_group_create来创建，然后使用函数dispatch_group_async来将block提交至一个dispatch queue，同时将它们添加至一个组。使用dispatch_group_notify 增加监听，当group内的bloc
iOS Concurrency - DispatchQueue、DispatchGroup、DispatchSemaphore
了凡
10-10 1867
本文内容来自Grand Central DispatchiOS Concurrency-队列、DispatchGroupSwift 3在Swift3中，GCD有关的API发生了一些变化，可参考: GCD Swift3.0 GCD精讲（Swift 3） 获取系统队列 1.获取系统主队列：let mainQ = DispatchQueue.main2.获取系统的全局队列DispatchQueue.gl
dispatch_group
10-18
两种方式都是模拟任务block内为异步操作的情况，方式一先执行的dispatch_group_notify里的代码，后执行的dispatch_group_async里的任务代码，这与我们的初衷相违背。如果任务block内为同步操作时，则无论哪种方式都不会出现这种状况。这也是dispatch_group的一个坑人的地方。我们在使用dispatch_group时一般都是想异步执行任务，所以，一定要注意这个坑
dispatch_group包含wait
10-18
以上两种方式都是模拟任务block内为异步操作的情况，方式一先执行的dispatch_group_notify里的代码，后执行的dispatch_group_async里的任务代码，这与我们的初衷相违背。如果任务block内为同步操作时，则无论哪种...
iOS应用程序中通过dispatch队列控制线程执行的方法
09-02
Grand Central Dispatch简称(GCD)是苹果公司开发的技术，以优化的应用程序支持多核心处理器和其他的对称多处理系统的系统,iOS应用程序中通过dispatch队列控制线程执行则是以并发来达到多核优化的重要途径.
Swift-dispatch-group
最新发布
03-31
Swift-dispatch_group
GCD中的dispatch_group函数的详解
Benson的学习笔记
03-30 3684
1、引入dispatch_group函数的目的在追加到dispatch_Queue中的多个处理全部结束后想要执行结束的处理,这种需求经常会在我们的程序中出现。(第一种情况)只使用一个Serial Dispatch Queue时,只要将想要执行的操作全部追加到串行队列,并在最后执行结束的操作即可实现(第二种情况)当我们使用Concurrent Dispatch Queue时或者使用多个Dispatch
dispatch_group_t
weixin_34067980的博客
12-04 114
Dispatch group用来阻塞一个线程，直到一个或多个任务完成执行。有时候你必须等待任务完成的结果，然后才能继续后面的处理。dispatch group也可以替代线程join。基本的流程是设置一个组，dispatch任务到queue，然后等待结果。你需要使用dispatch_group_async 函数，会关联任务到相关的组和queue。使用dispatch_group_wait等待一...
深入ObjC GCD中的dispatch group工作原理。
weixin_30462049的博客
03-17 161
本文是基于GCD的支持库libdispatch的源代码分析的结果或是用于作为源代码阅读的参考，尽量不帖代码，力求用UML图来说明工作流。 本文参考的源代码版本为v501.20.1，如有兴趣请自行到苹果的开源项目网站下载。 dispatch group的相关代码位于dispatch_semaphore.c模块中。下面是分析后的活动图： dispatch group是一个基于信号量的同步机制...
dispatch_group_enter 使用与讲解
pangshishan1的博客
03-19 7900
这个方法主要和下面几个方法一起使用的: dispatch_group_enter dispatch_group_leave dispatch_group_notify dispatch_group_wait dispatch_group_enter 和 dispatch_group_leave 一般是成对出现的, 进入一次，就得离开一次。也就是说，当离开和进入的次数相同时，就代表任务组完成...
iOS开发（OC）——Dispatch Group
菜鸟历程
11-05 1180
iOS开发交流群：301058503 上次提到，利用信号量实现异步线程的同步执行，开发中还经常遇到一种场景：有多个异步的网络请求并发执行，在所有的网络请求完成后统一刷新界面，该如何处理呢？ 我们可以用最笨的方法，在所有网络请求开始前，记录网络请求的总数totoalCount；然后用一个变量count记录网络请求结束的数量，在每一个网络请求结束后变量count++；当totoalCount==count时刷新界面。这样做也可以实现上述场景，但是感觉有点low，而且代码有点乱。有没有高大尚一点的做法呢？Disp
swift dispatchGroup
03-29
Swift DispatchGroup is a class in the Swift programming language that allows you to synchronize the execution of multiple tasks running on different threads. It helps you to manage the timing of asynchronous operations and avoid race conditions. A DispatchGroup is a lightweight mechanism for tracking a group of tasks. You can add tasks to a group, and the group will notify you when all of the tasks have completed. You can also specify a timeout for the group, after which the group will notify you if any of the tasks have not completed. Here is an example of how to use a DispatchGroup: ``` let group = DispatchGroup() group.enter() // run task 1 group.leave() group.enter() // run task 2 group.leave() group.notify(queue: .main) { // both tasks have completed } ``` In this example, we create a DispatchGroup called `group`. We then use the `enter()` and `leave()` methods to add two tasks to the group. The `notify()` method is called when both tasks have completed, and we can then perform any necessary actions. You can also use a DispatchGroup to wait for a group of tasks to complete before continuing execution. Here's an example: ``` let group = DispatchGroup() group.enter() // run task 1 group.leave() group.enter() // run task 2 group.leave() group.wait() // both tasks have completed ``` In this example, we use the `wait()` method to wait for both tasks to complete before continuing execution. This can be useful if you need to ensure that all tasks have completed before performing additional actions.

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值