devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

多线程(二)：GCD的基本使用，同步函数和异步函数，串行队列和并发队列，GCD队列组，栅栏函数，GCD单例_uigcd

作者：盐析白兔 | 2024-06-08 22:32:33

赞

踩

uigcd
  • 什么是GCD

    1）全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”

    2）纯C语言，提供了非常多强大的函数

  • GCD的优势

    1）GCD是苹果为多核的并行运算提出的解决方案。

    2）GCD会自动利用更多的CPU内核(比如双核，四核)。

    3）GCD会自动管理线程的生命周期(创建线程，调度任务)。

  • 任务和队列

    1）任务：执行什么操作

    2）队列：用来存放任务

  • GCD的使用就两个步骤

     1）定制任务(确定想做的事)

     2）将任务添加到队列(GCD会自动将队列中的任务取出，放到对应的线程中去执行; 任务的取出遵循队列的FIFO原则：先进先出，后进后出(栈是先进后出))

  • 执行任务

   GCD中有2个用来执行任务的常用函数

   1)  用同步的方式执行任务

    dispatch_sync(dispatch_queue_t  queue, dispatch_block_t block): queue: 队列  block: 任务

   2）用异步的方式执行任务

    dispatch_async(dispatch_queue_t  queue, dispatch_block_t block)

  • 同步和异步的区别

   1）同步：只能在当前的线程中执行任务，不具备开启新线程的能力

   2）异步：可以在新的线程中执行任务，具备开启新线程的能力

  • 队列的类型

    GCD的队列可以分为两大类型

    1. 并发队列

    1） 可以让多个任务并发同时执行（自动开启多个线程自动执行任务）

    2）并发功能只有在异步(dispatch_async)函数下才有效

    2. 串行队列

    1）让任务一个接一个的执行(一个任务执行完毕后，再执行下一个任务)

  • 容易混淆的术语

       有四个术语比较容易混淆：同步，异步，并发，串行

     1. 同步和异步的主要区别：能不能开启新的线程

     1）同步：只是在当前线程中执行任务，不具备开启新线程的能力

     2）异步：可以在新的线程中执行，具备开启新线程的能力

     2. 并发和串行的主要区别：任务的执行方式

      1）并发：允许多个任务并发(同时)执行

      2）串行：一个任务执行完毕后，再执行下一个任务

GCD的基本使用

  1. #import "ViewController.h"
  2.  
  3. @interface ViewController ()
  4.  
  5. @end
  6.  
  7. @implementation ViewController
  8.  
  9. #pragma mark ----------------------
  10. #pragma Events
  11. -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
  12. {
  13. //    [NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
  14.     
  15.     [self asyncConcurrent];
  16. }
  17.  
  18. #pragma mark ----------------------
  19. #pragma Methods
  20. //异步函数+并发队列:会开启多条线程,队列中的任务是并发执行
  21. //注意：并不是有多少个任务就开启多少个线程，是由系统内部决定的
  22. -(void)asyncConcurrent
  23. {
  24.     //1.创建队列
  25.     /*
  26.      第一个参数:C语言的字符串,标签
  27.      第二个参数:队列的类型
  28.         DISPATCH_QUEUE_CONCURRENT:并发
  29.         DISPATCH_QUEUE_SERIAL:串行
  30.      */
  31.     //dispatch_queue_t queue = dispatch_queue_create("com.www.download", DISPATCH_QUEUE_CONCURRENT);
  32.     
  33.     //获得全局并发队列
  34.     /*
  35.      第一个参数:优先级
  36.      第二个参数:
  37.      */
  38.     dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  39.     
  40.     NSLog(@"---satrt----");
  41.     
  42.     //2.1>封装任务2>添加任务到队列中
  43.     /*
  44.      第一个参数:队列
  45.      第二个参数:要执行的任务
  46.      */
  47.     dispatch_async(queue, ^{
  48.         NSLog(@"download1----%@",[NSThread currentThread]);
  49.     });
  50.     
  51.     dispatch_async(queue, ^{
  52.         NSLog(@"download2----%@",[NSThread currentThread]);
  53.     });
  54.     
  55.     dispatch_async(queue, ^{
  56.         NSLog(@"download3----%@",[NSThread currentThread]);
  57.     });
  58.     
  59.      NSLog(@"---end----");
  60. }
  61.  
  62. //异步函数+串行队列:会开线程,开一条线程,队列中的任务是串行执行的
  63. -(void)asyncSerial
  64. {
  65.     //1.创建队列
  66.     dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_SERIAL);
  67.  
  68.     //2.封装操作
  69.     dispatch_async(queue, ^{
  70.         NSLog(@"download1----%@",[NSThread currentThread]);
  71.     });
  72.     
  73.     dispatch_async(queue, ^{
  74.         NSLog(@"download2----%@",[NSThread currentThread]);
  75.     });
  76.     
  77.     dispatch_async(queue, ^{
  78.         NSLog(@"download3----%@",[NSThread currentThread]);
  79.     });
  80. }
  81.  
  82. //同步函数+并发队列:不会开线程,任务是串行执行的
  83. -(void)syncConcurrent
  84. {
  85.     //1.创建队列
  86.     dispatch_queue_t queue = dispatch_queue_create("com.www.download", DISPATCH_QUEUE_CONCURRENT);
  87.     
  88.     NSLog(@"---start---");
  89.     //2.封装任务
  90.     dispatch_sync(queue, ^{
  91.         NSLog(@"download1----%@",[NSThread currentThread]);
  92.     });
  93.     
  94.     dispatch_sync(queue, ^{
  95.         NSLog(@"download2----%@",[NSThread currentThread]);
  96.     });
  97.     
  98.     dispatch_sync(queue, ^{
  99.         NSLog(@"download3----%@",[NSThread currentThread]);
  100.     });
  101.     
  102.      NSLog(@"---end---");
  103. }
  104.  
  105. //同步函数+串行队列:不会开线程,任务是串行执行的
  106. -(void)syncSerial
  107. {
  108.     //1.创建队列
  109.     dispatch_queue_t queue = dispatch_queue_create("com.www.download", DISPATCH_QUEUE_SERIAL);
  110.     
  111.     //2.封装任务
  112.     dispatch_sync(queue, ^{
  113.         NSLog(@"download1----%@",[NSThread currentThread]);
  114.     });
  115.     
  116.     dispatch_sync(queue, ^{
  117.         NSLog(@"download2----%@",[NSThread currentThread]);
  118.     });
  119.     
  120.     dispatch_sync(queue, ^{
  121.         NSLog(@"download3----%@",[NSThread currentThread]);
  122.     });
  123. }
  124.  
  125. //异步函数+主队列:所有任务都在主线程中执行,不会开线程
  126. -(void)asyncMain
  127. {
  128.     //1.获得主队列
  129.     dispatch_queue_t queue = dispatch_get_main_queue();
  130.  
  131.     //2.异步函数
  132.     dispatch_async(queue, ^{
  133.         NSLog(@"download1----%@",[NSThread currentThread]);
  134.     });
  135.     
  136.     dispatch_async(queue, ^{
  137.         NSLog(@"download2----%@",[NSThread currentThread]);
  138.     });
  139.     
  140.     dispatch_async(queue, ^{
  141.         NSLog(@"download3----%@",[NSThread currentThread]);
  142.     });
  143. }
  144.  
  145. //同步函数+主队列:死锁
  146. //注意:如果该方法在子线程中执行,那么所有的任务在主线程中执行,不会死锁
  147. -(void)syncMain
  148. {
  149.     //1.获得主队列
  150.     dispatch_queue_t queue = dispatch_get_main_queue();
  151.     
  152.     NSLog(@"start----");
  153.     //2.同步函数
  154.     //同步函数:立刻马上执行,如果我没有执行完毕,那么后面的也别想执行
  155.     //异步函数:如果我没有执行完毕,那么后面的也可以执行
  156.     dispatch_sync(queue, ^{
  157.         NSLog(@"download1----%@",[NSThread currentThread]);
  158.     });
  159.     
  160.     dispatch_sync(queue, ^{
  161.         NSLog(@"download2----%@",[NSThread currentThread]);
  162.     });
  163.     
  164.     dispatch_sync(queue, ^{
  165.         NSLog(@"download3----%@",[NSThread currentThread]);
  166.     });
  167.     
  168.     NSLog(@"end---");
  169. }
  170. @end

   

各种队列的执行效果

 注意：使用sync(同步)函数往当前串行队列中添加任务，会卡住当前的串行队列，造成死锁

GCD实现线程间通信(子线程耗时下载，主线程更新UI)

  • 从子线程回到主线程

dispatch_async(

       dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        // 执行耗时的异步操作...

        dispatch_async(dispatch_get_main_queue(), ^{

         // 回到主线程，执行UI刷新操作

        });

});

  1. #import "ViewController.h"
  2.  
  3. @interface ViewController ()
  4. @property (weak, nonatomic) IBOutlet UIImageView *imageView;
  5.  
  6. @end
  7.  
  8. @implementation ViewController
  9.  
  10. -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
  11. {
  12.     //1.创建子线程下载图片
  13.     //DISPATCH_QUEUE_PRIORITY_DEFAULT 0
  14.     dispatch_async(dispatch_get_global_queue(0, 0), ^{
  15.        
  16.         //1.1 确定url
  17.         NSURL *url = [NSURL URLWithString:@"http://a.hiphotos.baidu.com/zhidao/wh%3D450%2C600/sign=da0ec79c738da9774e7a8e2f8561d42f/c83d70cf3bc79f3d6842e09fbaa1cd11738b29f9.jpg"];
  18.         
  19.         //1.2 下载二进制数据到本地
  20.        NSData *imageData =  [NSData dataWithContentsOfURL:url];
  21.         
  22.         //1.3 转换图片
  23.         UIImage *image = [UIImage imageWithData:imageData];
  24.         
  25.         NSLog(@"download----%@",[NSThread currentThread]);
  26.         
  27.         //更新UI
  28. //        dispatch_async(dispatch_get_main_queue(), ^{
  29.         dispatch_sync(dispatch_get_main_queue(), ^{
  30.             self.imageView.image = image;
  31.              NSLog(@"UI----%@",[NSThread currentThread]);
  32.         });
  33.         
  34.     });
  35. }
  36.  
  37. @end

GCD常用函数

  • 延时执行

    1）调用NSObject的方法

  • [self performSelector:@selector(run) withObject:nil afterDelay:2.0];

    // 2秒后再调run方法

     2）使用GCD函数

  • dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

        // 2秒后执行这里的代码...

    });

      3）使用NSTimer

  • [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];

  • 4）一次性代码

    1. //使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
    2. static dispatch_once_t onceToken;
    3. dispatch_once(&onceToken, ^{
    4.     // 只执行1次的代码(这里面默认是线程安全的)
    5. });

    5）代码示例

  1. #import "ViewController.h"
  2.  
  3. @interface ViewController ()
  4.  
  5. @end
  6.  
  7. @implementation ViewController
  8.  
  9. -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
  10. {
  11.     [self once];
  12. }
  13.  
  14. //延迟执行
  15. -(void)delay
  16. {
  17.     NSLog(@"start-----");
  18.     
  19.     //1. 延迟执行的第一种方法
  20.     //[self performSelector:@selector(task) withObject:nil afterDelay:2.0];
  21.     
  22.     //2.延迟执行的第二种方法
  23.     //[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(task) userInfo:nil repeats:YES];
  24.     
  25.     //3.GCD
  26. //    dispatch_queue_t queue = dispatch_get_main_queue();
  27.      dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
  28.     /*
  29.      第一个参数:DISPATCH_TIME_NOW 从现在开始计算时间
  30.      第二个参数:延迟的时间 2.0 GCD时间单位:纳秒
  31.      第三个参数:队列
  32.      */
  33.     dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), queue, ^{
  34.         NSLog(@"GCD----%@",[NSThread currentThread]);
  35.     });
  36.  
  37. }
  38.  
  39. //一次性代码
  40. //不能放在懒加载中的,应用场景:单例模式
  41. -(void)once
  42. {
  43.     static dispatch_once_t onceToken;
  44.     dispatch_once(&onceToken, ^{
  45.         NSLog(@"---once----");
  46.     });
  47. }
  48.  
  49. -(void)task
  50. {
  51.     NSLog(@"task----%@",[NSThread currentThread]);
  52. }
  53. @end

GCD栅栏函数

  • GCD中还有个用来执行任务的函数：

       dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

       在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行

  • 这个queue不能是全局的并发队列
  1. #import "ViewController.h"
  2.  
  3. @interface ViewController ()
  4.  
  5. @end
  6.  
  7. @implementation ViewController
  8.  
  9. -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
  10. {
  11.     
  12.     //0.获得全局并发队列
  13.     //栅栏函数不能使用全局并发队列，只能使用自己创建的并发队列
  14.     //dispatch_queue_t queue =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  15.     dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);
  16.     
  17.     //1.异步函数
  18.     dispatch_async(queue, ^{
  19.        
  20.         for (NSInteger i = 0; i<100; i++) {
  21.             NSLog(@"download1-%zd-%@",i,[NSThread currentThread]);
  22.         }
  23.         
  24.     });
  25.     
  26.     dispatch_async(queue, ^{
  27.         
  28.         for (NSInteger i = 0; i<100; i++) {
  29.             NSLog(@"download2-%zd-%@",i,[NSThread currentThread]);
  30.         }
  31.     });
  32.     
  33.     
  34.     //栅栏函数
  35.     dispatch_barrier_async(queue, ^{
  36.        
  37.         NSLog(@"+++++++++++++++++++++++++++++");
  38.     });
  39.     
  40.     dispatch_async(queue, ^{
  41.         
  42.         for (NSInteger i = 0; i<100; i++) {
  43.             NSLog(@"download3-%zd-%@",i,[NSThread currentThread]);
  44.         }
  45.     });
  46.     
  47.     dispatch_async(queue, ^{
  48.         
  49.         for (NSInteger i = 0; i<100; i++) {
  50.             NSLog(@"download4-%zd-%@",i,[NSThread currentThread]);
  51.         }
  52.     });
  53. }
  54.  
  55. @end

GCD快速迭代

  • 使用dispatch_apply函数能进行快速迭代遍历
  1. dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
  2.  
  3.     // 执行10次代码，index顺序不确定
  4.  
  5. });

剪切文件代码示例：

  1. #import "ViewController.h"
  2.  
  3. @interface ViewController ()
  4.  
  5. @end
  6.  
  7. @implementation ViewController
  8.  
  9. -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
  10. {
  11.     [self moveFileWithGCD];
  12. }
  13.  
  14. -(void)forDemo
  15. {
  16.     //同步，在主线程串行
  17.     for (NSInteger i = 0; i<10; i++) {
  18.         NSLog(@"%zd---%@",i,[NSThread currentThread]);
  19.     }
  20. }
  21.  
  22. //开子线程和主线程一起完成遍历任务,任务的执行时并发的
  23. -(void)applyDemo
  24. {
  25.     /*
  26.      第一个参数:遍历的次数
  27.      第二个参数:队列(并发队列)
  28.      第三个参数:index 索引
  29.      */
  30.     dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index) {
  31.         NSLog(@"%zd---%@",index,[NSThread currentThread]);
  32.     });
  33. }
  34.  
  35. //使用for循环
  36. -(void)moveFile
  37. {
  38.     //1.拿到文件路径
  39.     NSString *from = @"/Users/Alan/Desktop/from";
  40.     
  41.     //2.获得目标文件路径
  42.     NSString *to = @"/Users/Alan/Desktop/to";
  43.     
  44.     //3.得到目录下面的所有文件
  45.     NSArray *subPaths = [[NSFileManager defaultManager] subpathsAtPath:from];
  46.     
  47.     NSLog(@"%@",subPaths);
  48.     //4.遍历所有文件,然后执行剪切操作
  49.     NSInteger count = subPaths.count;
  50.     
  51.     for (NSInteger i = 0; i< count; i++) {
  52.         
  53.         //4.1 拼接文件的全路径
  54.        // NSString *fullPath = [from stringByAppendingString:subPaths[i]];
  55.         //在拼接的时候会自动添加/
  56.         NSString *fullPath = [from stringByAppendingPathComponent:subPaths[i]];
  57.         NSString *toFullPath = [to stringByAppendingPathComponent:subPaths[i]];
  58.         
  59.         NSLog(@"%@",fullPath);
  60.         //4.2 执行剪切操作
  61.         /*
  62.          第一个参数:要剪切的文件在哪里
  63.          第二个参数:文件应该被存到哪个位置
  64.          */
  65.         [[NSFileManager defaultManager]moveItemAtPath:fullPath toPath:toFullPath error:nil];
  66.         
  67.         NSLog(@"%@---%@--%@",fullPath,toFullPath,[NSThread currentThread]);
  68.     }
  69. }
  70.  
  71. -(void)moveFileWithGCD
  72. {
  73.     //1.拿到文件路径
  74.     NSString *from = @"/Users/Alan/Desktop/from";
  75.     
  76.     //2.获得目标文件路径
  77.     NSString *to = @"/Users/Alan/Desktop/to";
  78.     
  79.     //3.得到目录下面的所有文件
  80.     NSArray *subPaths = [[NSFileManager defaultManager] subpathsAtPath:from];
  81.     
  82.     NSLog(@"%@",subPaths);
  83.     //4.遍历所有文件,然后执行剪切操作
  84.     NSInteger count = subPaths.count;
  85.     
  86.     dispatch_apply(count, dispatch_get_global_queue(0, 0), ^(size_t i) {
  87.         //4.1 拼接文件的全路径
  88.         // NSString *fullPath = [from stringByAppendingString:subPaths[i]];
  89.         //在拼接的时候会自动添加/
  90.         NSString *fullPath = [from stringByAppendingPathComponent:subPaths[i]];
  91.         NSString *toFullPath = [to stringByAppendingPathComponent:subPaths[i]];
  92.         
  93.         NSLog(@"%@",fullPath);
  94.         //4.2 执行剪切操作
  95.         /*
  96.          第一个参数:要剪切的文件在哪里
  97.          第二个参数:文件应该被存到哪个位置
  98.          */
  99.         [[NSFileManager defaultManager]moveItemAtPath:fullPath toPath:toFullPath error:nil];
  100.         
  101.         NSLog(@"%@---%@--%@",fullPath,toFullPath,[NSThread currentThread]);
  102.  
  103.     });
  104. }
  105. @end

GCD队列组

  • 队列组使用情况

     1）分别异步执行多个耗时的操作

     2）等多个异步操作都执行完毕后，再回到主线程执行操作

    3）拦截通知,当队列组中所有的任务都执行完毕的时候回进入到下面的方法，异步的，不会阻塞线程

  1. dispatch_group_t group =  dispatch_group_create();
  2.  
  3. dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  4.  
  5.     // 执行1个耗时的异步操作
  6.  
  7. });
  8.  
  9. dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
  10.  
  11.     // 执行1个耗时的异步操作
  12.  
  13. });
  14.  
  15. dispatch_group_notify(group, dispatch_get_main_queue(), ^{
  16.  
  17.     // 等前面的异步操作都执行完毕后，回到主线程...
  18.  
  19. });

 下载两张图片合并成一张代码示例：

  1. #import "ViewController.h"
  2.  
  3. @interface ViewController ()
  4. /** 图片1 */
  5. @property (nonatomic, strong) UIImage *image1;
  6. /** 图2 */
  7. @property (nonatomic, strong) UIImage *image2;
  8.  
  9. @property (weak, nonatomic) IBOutlet UIImageView *imageView;
  10. @end
  11.  
  12. @implementation ViewController
  13.  
  14. #pragma mark ----------------------
  15. #pragma mark Events
  16.  
  17. -(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
  18. {
  19.     [self test];
  20. }
  21. #pragma mark ----------------------
  22. #pragma mark Methods
  23. -(void)group1
  24. {
  25.     //1.创建队列
  26.     dispatch_queue_t queue =dispatch_get_global_queue(0, 0);
  27.     
  28.     //2.创建队列组
  29.     dispatch_group_t group = dispatch_group_create();
  30.     
  31.     //3.异步函数
  32.     /*
  33.      1)封装任务
  34.      2)把任务添加到队列中
  35.      dispatch_async(queue, ^{
  36.      NSLog(@"1----%@",[NSThread currentThread]);
  37.      });
  38.      */
  39.     /*
  40.      1)封装任务
  41.      2)把任务添加到队列中
  42.      3)会监听任务的执行情况,通知group
  43.      */
  44.     dispatch_group_async(group, queue, ^{
  45.         NSLog(@"1----%@",[NSThread currentThread]);
  46.     });
  47.     
  48.     
  49.     dispatch_group_async(group, queue, ^{
  50.         NSLog(@"2----%@",[NSThread currentThread]);
  51.     });
  52.     
  53.     dispatch_group_async(group, queue, ^{
  54.         NSLog(@"3----%@",[NSThread currentThread]);
  55.     });
  56.     
  57.     //拦截通知,当队列组中所有的任务都执行完毕的时候回进入到下面的方法，异步的，不会阻塞线程
  58.     dispatch_group_notify(group, queue, ^{
  59.         
  60.         NSLog(@"-------dispatch_group_notify-------");
  61.     });
  62.     
  63.         NSLog(@"----end----");
  64.  
  65. }
  66.  
  67. -(void)group2
  68. {
  69.     //1.创建队列
  70.     dispatch_queue_t queue =dispatch_get_global_queue(0, 0);
  71.     
  72.     //2.创建队列组
  73.     dispatch_group_t group = dispatch_group_create();
  74.     
  75.     //3.在该方法后面的异步任务会被纳入到队列组的监听范围,进入群组
  76.     //dispatch_group_enter|dispatch_group_leave 必须要配对使用
  77.     dispatch_group_enter(group);
  78.     
  79.     dispatch_async(queue, ^{
  80.         NSLog(@"1----%@",[NSThread currentThread]);
  81.         
  82.         //离开群组
  83.         dispatch_group_leave(group);
  84.     });
  85.     
  86.     dispatch_group_enter(group);
  87.     
  88.     dispatch_async(queue, ^{
  89.         NSLog(@"2----%@",[NSThread currentThread]);
  90.     
  91.         //离开群组
  92.         dispatch_group_leave(group);
  93.     });
  94.     
  95.     
  96.     //拦截通知
  97.     //问题?该方法是阻塞的吗?  内部本身是异步的
  98. //    dispatch_group_notify(group, queue, ^{
  99. //        NSLog(@"-------dispatch_group_notify-------");
  100. //    });
  101.     
  102.     //等待.死等. 直到队列组中所有的任务都执行完毕之后才能执行
  103.     //阻塞的，会阻塞线程
  104.     dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
  105.     NSLog(@"----end----");
  106.     
  107. }
  108.  
  109. -(void)group3
  110. {
  111.     /*
  112.      1.下载图片1 开子线程
  113.      2.下载图片2 开子线程
  114.      3.合成图片并显示图片 开子线程
  115.      */
  116.     
  117.     //-1.获得队列组
  118.     dispatch_group_t group = dispatch_group_create();
  119.     
  120.     //0.获得并发队列
  121.     dispatch_queue_t queue =  dispatch_get_global_queue(0, 0);
  122.     
  123.     // 1.下载图片1 开子线程
  124.     dispatch_group_async(group, queue,^{
  125.         
  126.         NSLog(@"download1---%@",[NSThread currentThread]);
  127.         //1.1 确定url
  128.         NSURL *url = [NSURL URLWithString:@"http://www.qbaobei.com/tuku/images/13.jpg"];
  129.         
  130.         //1.2 下载二进制数据
  131.         NSData *imageData = [NSData dataWithContentsOfURL:url];
  132.         
  133.         //1.3 转换图片
  134.         self.image1 = [UIImage imageWithData:imageData];
  135.     });
  136.     
  137.     // 2.下载图片2 开子线程
  138.      dispatch_group_async(group, queue,^{
  139.          
  140.          NSLog(@"download2---%@",[NSThread currentThread]);
  141.          //2.1 确定url
  142.         NSURL *url = [NSURL URLWithString:@"http://pic1a.nipic.com/2008-09-19/2008919134941443_2.jpg"];
  143.         
  144.         //2.2 下载二进制数据
  145.         NSData *imageData = [NSData dataWithContentsOfURL:url];
  146.         
  147.         //2.3 转换图片
  148.         self.image2 = [UIImage imageWithData:imageData];
  149.     });
  150.  
  151.     //3.合并图片
  152.     //主线程中执行
  153.     dispatch_group_notify(group, dispatch_get_main_queue(), ^{
  154.        
  155.         NSLog(@"combie---%@",[NSThread currentThread]);
  156.         //3.1 创建图形上下文
  157.         UIGraphicsBeginImageContext(CGSizeMake(200, 200));
  158.         
  159.         //3.2 画图1
  160.         [self.image1 drawInRect:CGRectMake(0, 0, 200, 100)];
  161.         self.image1 = nil;
  162.         
  163.         //3.3 画图2
  164.         [self.image2 drawInRect:CGRectMake(0, 100, 200, 100)];
  165.         self.image2 = nil;
  166.         
  167.         //3.4 根据上下文得到一张图片
  168.         UIImage *image =  UIGraphicsGetImageFromCurrentImageContext();
  169.         
  170.         //3.5 关闭上下文
  171.         UIGraphicsEndImageContext();
  172.         
  173.         //3.6 更新UI
  174. //        dispatch_async(dispatch_get_main_queue(), ^{
  175.         
  176.             NSLog(@"UI----%@",[NSThread currentThread]);
  177.             self.imageView.image = image;
  178. //        });
  179.     });
  180.     
  181. //    dispatch_release(group)
  182. }
  183.  
  184. -(void)test
  185. {
  186.    // dispatch_async(<#dispatch_queue_t queue#>, <#^(void)block#>)
  187.     //区别:封装任务的方法(block--函数)
  188.     /*
  189.      第一个参数:队列
  190.      第二个参数:参数
  191.      第三个参数:要调用的函数的名称
  192.      */
  193.     dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, task);
  194.     dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, task);
  195.     dispatch_async_f(dispatch_get_global_queue(0, 0), NULL, task);
  196. }
  197.  
  198. void task(void *param)
  199. {
  200.     NSLog(@"%s---%@",__func__,[NSThread currentThread]);
  201. }
  202.  
  203. @end

GCD单例模式

  • 单例模式的作用

   1）可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问

   2）从而方便地控制了实例个数，并节约系统资源

  • 单例模式的使用场合
  • 在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）
  • ARC中，单例模式的实现

    1）在.m中保留一个全局的static的实例

static id _instance;

     2）重写allocWithZone:方法，在这里创建唯一的实例（注意线程安全）

  1. + (instancetype)allocWithZone:(struct _NSZone *)zone
  2.  
  3. {
  4.  
  5.     static dispatch_once_t onceToken;
  6.  
  7.     dispatch_once(&onceToken, ^{
  8.  
  9.         _instance = [super allocWithZone:zone];
  10.  
  11.     });
  12.  
  13.     return _instance;
  14.  
  15. }
  • 提供1个类方法让外界访问唯一的实例
  1. + (instancetype)sharedInstance
  2.  
  3. {
  4.  
  5.     static dispatch_once_t onceToken;
  6.  
  7.     dispatch_once(&onceToken, ^{
  8.  
  9.         _instance = [[self alloc] init];
  10.  
  11.     });
  12.  
  13.     return _instance;
  14.  
  15. }

 

  • 实现copyWithZone:方法
  1. - (id)copyWithZone:(struct _NSZone *)zone
  2.  
  3. {
  4.  
  5.     return _instance;
  6.  
  7. }

 具体单例代码：

AlanTool.h

  1. #import <Foundation/Foundation.h>
  2.  
  3. @interface AlanTool : NSObject<NSCopying, NSMutableCopying>
  4.  
  5. //类方法
  6. //1.方便访问
  7. //2.标明身份
  8. //3.注意:share+类名|default + 类名 | share | default | 类名
  9. +(instancetype)shareTool;
  10. @end

AlanTool.m

  1. #import "AlanTool.m"
  2.  
  3. @implementation AlanTool
  4.  
  5. //0.提供全局变量
  6. static AlanTool *_instance;
  7.  
  8. //1.alloc-->allocWithZone
  9. +(instancetype)allocWithZone:(struct _NSZone *)zone
  10. {
  11.     //加互斥锁解决多线程访问安全问题
  12. //    @synchronized(self) {
  13. //        if (_instance == nil) {
  14. //            _instance = [super allocWithZone:zone];
  15. //        }
  16. //    }
  17.     
  18.     //本身就是线程安全的
  19.     static dispatch_once_t onceToken;
  20.     dispatch_once(&onceToken, ^{
  21.         _instance = [super allocWithZone:zone];
  22.     });
  23.     
  24.     return _instance;
  25. }
  26.  
  27. //2.提供类方法
  28. +(instancetype)shareTool
  29. {
  30.     //1
  31.     //return [[self alloc]init];
  32.     //2
  33.     static dispatch_once_t onceToken;
  34.     dispatch_once(&onceToken, ^{
  35.         _instance = [super allocWithZone:zone];
  36.     });
  37.     
  38.     return _instance;
  39. }
  40.  
  41. //3.严谨
  42. -(id)copyWithZone:(NSZone *)zone
  43. {
  44.     return _instance;
  45. }
  46.  
  47. -(id)mutableCopyWithZone:(NSZone *)zone
  48. {
  49.     return _instance;
  50. }
  51.  
  52. #if __has_feature(objc_arc)
  53. //条件满足 ARC
  54. #else
  55. // MRC
  56. -(void)release
  57. {
  58.     
  59. }
  60.  
  61. -(instancetype)retain
  62. {
  63.     return _instance;
  64. }
  65.  
  66. //习惯
  67. -(NSUInteger)retainCount
  68. {
  69.     return MAXFLOAT;
  70. }
  71.  
  72. #endif
  73.  
  74. @end

通过宏实现GCD单例模式

  1. #define SingleH(name) +(instancetype)share##name;
  2.  
  3. #if __has_feature(objc_arc)
  4. //条件满足 ARC
  5. #define SingleM(name) static id _instance;\
  6. +(instancetype)allocWithZone:(struct _NSZone *)zone\
  7. {\
  8. static dispatch_once_t onceToken;\
  9. dispatch_once(&onceToken, ^{\
  10. _instance = [super allocWithZone:zone];\
  11. });\
  12. \
  13. return _instance;\
  14. }\
  15. \
  16. +(instancetype)share##name\
  17. {\
  18. return [[self alloc]init];\
  19. }\
  20. \
  21. -(id)copyWithZone:(NSZone *)zone\
  22. {\
  23. return _instance;\
  24. }\
  25. \
  26. -(id)mutableCopyWithZone:(NSZone *)zone\
  27. {\
  28. return _instance;\
  29. }
  30.  
  31. #else
  32. //MRC
  33. #define SingleM(name) static id _instance;\
  34. +(instancetype)allocWithZone:(struct _NSZone *)zone\
  35. {\
  36. static dispatch_once_t onceToken;\
  37. dispatch_once(&onceToken, ^{\
  38. _instance = [super allocWithZone:zone];\
  39. });\
  40. \
  41. return _instance;\
  42. }\
  43. \
  44. +(instancetype)share##name\
  45. {\
  46. return [[self alloc]init];\
  47. }\
  48. \
  49. -(id)copyWithZone:(NSZone *)zone\
  50. {\
  51. return _instance;\
  52. }\
  53. \
  54. -(id)mutableCopyWithZone:(NSZone *)zone\
  55. {\
  56. return _instance;\
  57. }\
  58. -(oneway void)release\
  59. {\
  60. }\
  61. \
  62. -(instancetype)retain\
  63. {\
  64.     return _instance;\
  65. }\
  66. \
  67. -(NSUInteger)retainCount\
  68. {\
  69.     return MAXFLOAT;\
  70. }
  71. #endif

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/691468
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号