3.GCD

GCD的全称是Grand Central Dispatch,提供了非常多的纯C语言的函数

GCD的优势

优势:性能非常好
1.GCD是苹果公司为多核的并行运算提出的解决方案
2.GCD会自动利用更多的CPU内核(比如双核,四核)
3.GCD会自动管理线程的生命周期(创建线程,调度线程,销毁线程)
4.程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码

GCD的两个核心的概念 (任务和队列)

• 任务:是指执行什么操作
  • 执行任务的方式:
    分为"同步执行"和"异步执行"两种方式
    **同步执行 : **如果我(当前的任务)没有执行完毕,后边的任务将永远无法执行
    **异步执行 : **我(当前的任务)无所谓,我没执行完,后面的也可以执行
• 执行任务时常用的函数
  分为"同步函数"和"异步函数"两种函数
  **同步函数(dispatch_sync) : **只能在当前线程中执任务,不具备开启新线程的能力(永远不开线程)

参数: queue :队列    block:任务
          dispatch_sync(<#dispatch_queue_t queue#>, <#^(void)block#>)

**异步函数(dispatch_async) : **可以在新的线程中执行任务,具备开启新的线程的能力(具备不代表一定要开启)

参数: queue :队列    block:任务
          dispatch_async(<#dispatch_queue_t queue#>, <#^(void)block#>)

• 使用GCD的两个步骤
  1.定制任务:确定想做的事情
  2.将任务添加到队列中
  1.GCD会自动将队列中的任务取出,放到对应的线程中执行
  2.任务的取出会遵循队列的FIFO原则:先进先出,后今后出(类似一个管道,先进去的,先从另一面出来))
• 队列:是用来存放什么任务
  GCD中的队列分为两种:并发队列和串行队列
  • 串行队列
    让任务一个接着一个的执行(上一个任务执行完毕后,再执行下一个任务)
    • 串行队列分为两种:自己创建的的串行队列 和 主队列

//自己创建的串行队列
dispatch_queue_t queue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);
//主队列
dispatch_queue_t queue2 = dispatch_get_main_queue();

• 并发队列
  可以让多个任务同时执行,不过并发队列的这种特性只有在异步函数下才有效果(因为同步函数没有添加子线程的能力)
  "并发"的解释:指的是多个任务同时执行的"现象",并且要求有子线程
  - 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
  - 并发功能只有在"异步函数(dispatch_async)"下才会有效

  • 并发队列分为两种:自己创建的并发队列 和 全局并发队列

//自己创建的并发队列
dispatch_queue_t queue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
//全局并发队列
系统内部默认提供4个全局并发队列的优先级如下:
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 中
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台
//获取全局并发队列(系统启动就已经有了)
dispatch_queue_t queue1 = dispatch_get_global_queue(DISPATCH
_QUEUE_PRIORITY_DEFAULT, 0);
//参数解释
第一个参数:传入某一个全局并发队列
第二个参数:写0(没有用的参数);

• 并发队列和串行队列执行任务的方式
  并发队列 : 执行任务的方式是将队列中的任务一次性并依次取出来,拿到外边执行任务,并发队列将任务取出来之后就不再关心你怎么执行了
  串行队列 : 将队列中的任务先取出第一个,到外边执行,并监听这个任务是否执行完毕,如果执行完毕再取出第二个任务来执行任务,并继续监听

GCD的基本使用

• 1.创建队列

"第一个参数:"C语言的字符串,给队列起一个名字或者是标识
*注意* : 函数都是C语言的函数,在写字符串的时候,不要加@
         通常命名规范为公司域名加功能,"例如:com.xxx公司域名.www.download"
"第二个参数:"队列的类型      
 DISPATCH_QUEUE_CONCURRENT  并发
 DISPATCH_QUEUE_Serial      串行队列 
//获取并发队列
dispatch_queue_t queue = dispatch_queue_create("concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
//获取串行队列
dispatch_queue_t queue = dispatch_queue_create("serialQueue", DISPATCH_QUEUE_SERIAL);

• 2.使用函数封装任务,并添加到队列中

"第一个参数" : 队列
"第二个参数" : block 用来封装任务
//异步函数封装
dispatch_async(queue, ^{
       for (NSInteger i = 0; i <10; i++) {
           NSLog(@"%zd----------",i);
       }
 });
//同步函数封装
dispatch_sync(queue, ^{
       for (NSInteger i = 0; i <10; i++) {
           NSLog(@"%zd----------",i);
       }
});

队列与函数的组合

• 1.异步函数 + 并发队列 - 异步函数会开多条子线程,队列的任务是并发执行

//异步函数 + 并发队列
(会开辟多个子线程,并且任务是在新开辟的多个子线程内分别执行任务,
无论是在主线程中调用test方法还是在非主线程总调用test方法,都会开启多个子线程,
并且在新开辟的多个子线程内,并发执行任务)
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"async + concurrent--------1--------%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"async + concurrent--------2--------%@",[NSThread currentThread]);
    });

• 2.异步函数 + 串行队列 - 只开启一条子线程,队列里的任务是串行执行的,串行执行一定是按顺序执行的
  ** 注意:**异步函数+ 串行队列只要不是在主队列,一定会开一条子线程

//异步函数 + 串行队列
(会开辟一个子线程,并且在子线程内串行执行任务,
无论是在主线程中调用test方法还是在非主线程中调用test方法,都会开辟一个子线程,
并且在这个开辟的子线程内串行执行任务)
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
        NSLog(@"async + serial-------1--------%@",[NSThread currentThread]);
    });
dispatch_async(queue, ^{
        NSLog(@"async + serial-------2--------%@",[NSThread currentThread]);
    });

• 3.同步函数 + 并发队列 - 不会开新的线程,所有的任务只会在当前线程中串行执行
  ** 注意:**同步函数不一定都是在主线程中执行,只有正在主队列中才会在主线程中执行

//同步函数 + 并发队列
(在当前线程中串行执行,不会开辟子线程,
如果是在主线程中调用test,那么当前线程就是主线程;
如果是在非主线程中调用,那么当前线程就是子线程,同步函数也是在当前线程中执行)
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
        NSLog(@"sync + concurrent------1-----%@",[NSThread currentThread]);
    });
dispatch_sync(queue, ^{
        NSLog(@"sync + concurrent------2-----%@",[NSThread currentThread]);
    });

• 4.同步函数 + 串行队列 - 不会开新的线程,所有的任务只会在当前线程中串行执行

//同步函数 + 串行队列
(在当前线程中串行执行,
如果是在主线程中调用test方法,当前线程是主线程;
如果是在非主线程中调用这个方法,当前线程就是子线程,同步函数也是在当前线程中执行)
dispatch_queue_t queue = dispatch_queue_create("sync + serial", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
        NSLog(@"sync + serial----1---%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"sync + serial----2---%@",[NSThread currentThread]);
    });

特殊队列与函数的组合

• 全局并发队列 + 异步函数

//全局并发队列 + 异步函数
(会开辟多个子线程,并且任务是在新开辟的子线程内执行,
无论是在主线程中调用test方法,还是在非主线程中调用test方法,那么都会开辟多个子线程,
并且任务是在新开辟的子线程内以并发的方式执行)
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"async + globalQueue --------1---------%@",[NSThread currentThread]);
    });
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"async + globalQueue --------2---------%@",[NSThread currentThread]);
    });

• 全局并发队列 + 同步函数

//全局并发队列 + 同步函数
(如果是在主线程中调用test方法,那么任务是在主线程中以串行的方式执行,不会开辟子线程,
如果是在非主线程中调用test方法,那么任务是在调用test方法的非主线程内,以串行方式执行,不会开辟子线程)
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"sync + globalQueue -------1--------%@",[NSThread currentThread]);
    });
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"sync + globalQueue -------2--------%@",[NSThread currentThread]);
    });

• 主队列 + 异步函数

//主队列 + 异步函数
(不会开辟子线程,任务在当前主线程中以串行的方式执行,
无论是在主线程中调用test方法还是在非主线程中调用test方法,
任务都是在主线程中以串行的方式执行)
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"async + mainQueue--------1-------%@",[NSThread currentThread]);
    });
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"async + mainQueue--------2-------%@",[NSThread currentThread]);
    });

• 主队列 + 同步函数(会形成死锁)

//主队列 + 同步函数
(形成死锁,在主队列中的任务,只能在主线程中执行,
如果是在主线程中调用test方法,当前线程是主线程,那么会形成死锁,
如果是在非主线程中调用test方法,那么不会形成死锁,
并且任务是在主线程中,以串行的方式执行)
    NSLog(@"来到了test方法内");
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"sync + mainQueue ----------1--------%@",[NSThread currentThread]);
    });
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"sync + mainQueue ----------2--------%@",[NSThread currentThread]);
    });
主队列的特点:  
  1.凡是在主队列中的任务,都必须要在主线程中来执行,它与全局并发队列相同,也是在程序一启动就默认存在的队列
  2.主队列在调度任务的时候,会先检查主线程的状态,如果发现主线程处于繁忙状态,就会暂停调度
//死锁形成的原因
    同步函数会监听当前任务完成后,再执行下一个任务,
    也就是说,同步函数 会等到 刚添加到主队列的 block 执行完成才会返回，
    然而主队列是串行队列，同步函数中的 block 是后加入的，前一个是主线程正在执行的方法(当前的主线程在执行 同步函数函数 所在的方法)，
    所以 同步函数 想执行 block 必须等待主线程执行完成，而主线程又在等待 同步函数 返回，去执行后续内容。
    同步函数 等待 主线程 执行完成， 主线程 等待 同步函数返回 ,这样就造成死锁

GCD的常用函数

1.延迟执行函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"GCD----%@",[NSThread currentThread]);
      });
 /*
      第一个参数:delayInSeconds 要延迟的时间 GCD的时间是以纳秒为单位
     第二个参数:队列  决定block中的任务在哪个线程中执行
     */

**作用 : **延迟一段时间后再执行,可以通过设置队列,指定block在哪个线程中调用
**原理 : **延迟把block内容提交到队列而不是先将block添加到队列后再延迟调度

//例如下面的工程中,执行到after的时候会延迟4秒再提交到队列,
//在并发的情况下,这4秒足以把队列中其他的任务都处理完毕了,
//所以,delay mission是最后才被执行的
dispatch_queue_t queue = dispatch_queue_create("com.lyu.www.test", DISPATCH_QUEUE_CONCURRENT);    
dispatch_async(queue, ^{        
      NSLog(@"first mission");    
});
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(4.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"delay mission");
    });   
 dispatch_async(queue, ^{        
    NSLog(@"last mission");
    });

**注意 : **dispatch_after方法本身是异步的
**拓展 : **
除了GCD的延迟的方法,还有两种延迟执行的方法:

// 主循环的延迟执行的方法
//afterDelay 延迟的时间 秒为单位 2.0秒
[self performSelector:@selector(task) withObject:nil afterDe
lay:2.0];
//定时器的延迟执行
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self sele ctor:@selector(task) userInfo:nil repeats:NO];

2.GCD的一次性函数

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
      NSLog(@"---once---");
});

作用:
1.能够保证在整个程序运行过程总,block中的代码只会执行一次
判断方法:使用静态变量记录当前block有没有被执行过,如果执行过来就不会再执行了
2.(重要)线程是安全的
3.应用:单例模式
使用方法
1.首先要定义一个dispatch_once_t变量,用于记录代码重复的次数;
2.然后敲dispatch_once代码块,执行某段代码,利用变量来控制如果不是第一次执行就不执行

3.GCD的栅栏函数

主要用于异步函数+并发队列,因为同步函数一定是串行执行的
任务执行顺序 : **
栅栏函数之前的任务(执行完毕)--> 栅栏函数的任务(执行完毕)--> 栅栏函数
之后的任务
注意点 : **
1.栅栏函数只能对自己创建的并发队列有效(对全局并发队列无效)
2.所有要通过栅栏控制顺序的任务要放在同一个队列中
3.如果要使用主队列, 则要注意不要在主线程执行含有同步函数的方法(同步函数的任务会被加到主队列), 否则死锁

dispatch_barrier_async(queue, ^{ 
     NSLog(@"栅栏函数");
 });

**作用 : **
1.能过控制队列中,任务的执行顺序
2.只要添加栅栏函数,就能保证,栅栏函数前的任务先执行完后,再执行栅栏函数后的任务

示例:
//创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("barrier", DISPATCH_QUEUE_CONCURRENT);    //用函数封装方法,并添加到队列中
    dispatch_async(queue, ^{  NSLog(@"栅栏前任务1",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏前任务2",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏前任务3",);  });
    //栅栏函数,
    dispatch_barrier_async(queue, ^{  NSLog(@"+++++++++++++++++++"); });
    //普通的异步函数
    dispatch_async(queue, ^{  NSLog(@"栅栏后任务1",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏后任务2",);  });
    dispatch_async(queue, ^{  NSLog(@"栅栏后任务3",);  });
//运行结果:前三个任务是无序的,后三个任务也是无序的,但是前三个任务会先执行,执行完毕之后再执行后三个任务

4.GCD的迭代

GCD的迭代,其实就是遍历,只是普通的遍历都是在当前的线程中串行执行的,遍历的效率不高
GCD的迭代是在多个线程(包括主线程)中,并发的执行的,执行效率相比较普通的遍历要高一些
** 注意:** 1)不能使用主队列,否则会发生死锁,因为主队列也会一起参与迭代

//第一个参数:要迭代的次数
//第二个参数:队列 (注意点:不能使用主队列)
//第三个参数:blocks(设置索引)
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t i) {
       NSLog(@"%zd---%@",i,[NSThread currentThread]);
});

快速迭代与死锁:
死锁问题:因为主线程会一起参与迭代,所以如果在主队列执行迭代的话,再加上主线程的特性,会造成死锁

dispatch_queue_t queue = dispatch_get_main_queue();  //主线程死锁
NSLog(@"死锁之前"); 
dispatch_apply(10, queue, ^(size_t i) {        
      NSLog(@"%ld--%@",i,[NSThread currentThread]);
  });

问题点:快速迭代中所有的任务都是在多个线程中(包括主线程)中并发执行的(无序执行的)

GCD迭代函数应用的示例:

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{   
 //获取被剪切文件的原始路径    
NSString * fromPath = @"/Users/mario/Desktop/from";    
//获取被剪切文件的目标路径    
NSString * toPath = @"/Users/mario/Desktop/to";    
//获取被剪切文件的原始路径内的子路径数    
NSArray * subPathArray = [[NSFileManager defaultManager] subpathsAtPath:fromPath];   
//获取子路径的个数
NSInteger count = subPathArray.count;
//迭代遍历    
//第一个参数:遍历的次数    
//第二个参数:队列(注意不要用主队列,因为主线程和子线程会一起执行迭代任务)
    dispatch_apply(count, dispatch_get_global_queue(0, 0), ^(size_t index) {
        //获取完成的原始路径        
        NSString * fromFullPath = [fromPath stringByAppendingPathComponent:subPathArray[index]];                
        //获取完整的目标路径
        NSString * toFullPath = [toPath stringByAppendingPathComponent:subPathArray[index]];
        //将要剪切的文件从原来文件夹中移动到目标文件夹        
        [[NSFileManager defaultManager] moveItemAtPath:fromFullPath toPath:toFullPath error:nil];          
        //打印当前路径
         NSLog(@"--------%@",[NSThread currentThread]);
    });
}

//补充:
如何得到文件路径下的所有文件 : subpathsAtPath:
如何拼接文件全路径 : stringByAppendingPathComponent
移动文件的方法:
//参数解释
//第一个参数:文件在哪里
//第二个参数:移动到哪里
//第三个参数:错误信息,可以给nil
[[NSFileManager defaultManager] moveItemAtPath:fromeFullPath toPath:toFullPath error:nil];

5.GCD的队列组

应用场景:用于只有在某些任务执行完毕之后,才能执行指定的任务

• 实现队列组的函数:方式一

//获取队列组管理队列
dispatch_group_t group =dispatch_group_create();
//队列组监听任务是否执行完成
 dispatch_group_async(group, queue, ^{ });
//拦截通知 
dispatch_group_notify

示例:
-(void)group1{   
//1.获得队列组管理队列    
dispatch_group_t group = dispatch_group_create();    
//2.获得并发队列
dispatch_queue_t queue = dispatch_queue_create("group", DISPATCH_QUEUE_CONCURRENT);
//通过队列组监听队列中任务的执行状态
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad1-----%@",[NSThread currentThread]); });
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad2-----%@",[NSThread currentThread]); });
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad3-----%@",[NSThread currentThread]); });
dispatch_group_async(group, queue, ^{  NSLog(@"downLoad4-----%@",[NSThread currentThread]); });
//拦截通知,当队列组内的所有任务都执行完毕后,会调用这个方法
//保证队列组中所有的下载任务完成之后再刷新UI界面
dispatch_group_notify(group, queue, ^{  
    NSLog(@"----end-----%@",[NSThread currentThread]);  });
    NSLog(@"++++++++++++++++%@",[NSThread currentThread]);
}

• 实现队列组的函数:方式二
  dispatch_group_enter & dispatch_group_leave这个两个方法是成对使用的

//进入队列组
dispatch_group_enter(group);
//任务执行完毕后,离开队列组
dispatch_group_leave(group);

示例:
-(void)group2{    
//获取队列组    
dispatch_group_t group = dispatch_group_create();    
//获取队列
dispatch_queue_t queue = dispatch_queue_create("group2", DISPATCH_QUEUE_CONCURRENT);
//将异步的任务纳入队列组中进行监视    dispatch_group_enter(group);
dispatch_async(queue, ^{  NSLog(@"downLoad1-----%@",[NSThread currentThread]);
        //通知队列组,该任务已经完成
        dispatch_group_leave(group);   
//注意:一定要写在封装任务的函数内});
dispatch_group_enter(group);
dispatch_async(queue, ^{  NSLog(@"download2-----%@",[NSThread currentThread]);
         dispatch_group_leave(group); });
dispatch_group_enter(group);
dispatch_async(queue, ^{  NSLog(@"download3-----%@",[NSThread currentThread]);
         dispatch_group_leave(group); });
//拦截通知    
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 0.0001 * NSEC_PER_SEC);    
long num = dispatch_group_wait(group, time);    
NSLog(@"%ld",num);
}

**注意 : **
1.将多个任务添加到队列组中不影响队列的原本的同步异步性,
2.所有的函数,包括队列组之外的任务的同步/异步性都没有影响
比如:有N个任务,添加到队列组M个任务,队列组内的M个任务和队列组外的N-M个任务的同步/异步的执行是不受影响的,和之前一样
3.dispatch_group_notify是异步函数,只有当队列组中所有的任务全部执行完,才会执行这个函数的回调的内容,不论放在哪个位置,永远是队列组内最后执行的

拦截队列通知的方法
**方法一 : **dispatch_group_notify

         dispatch_group_notify(group, queue, ^{
             NSLog(@"--end---");
         });

**方法二 : ** dispatch_group_wait等待队列组里的任务的执行(需要设置等待时间),是同步函数
注意 : dispatch_group_wait方法是与队列组中的任务同步执行的,与(notify异步不同)

dispatch_time_t timer = dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC);
时间参数解读:当前传入的时间是2秒,意味着只等2秒,不管队列中的任务有没有执行完毕都会继续往下执行
如果时间传入的是 DISPATCH_TIME_FOREVER(死等),一直要等到队列组中所有的任务都执行完毕之后,才会继续往下执行

long n = dispatch_group_wait(group, timer);
//如果在timer时间内完成所有的任务,那么就返回0,否则返回非零值(注意不一定是1)

dispatch_async_f介绍
是一个异步函数,该方法使用函数来封装任务
第二个参数:要调用函数的参数(可以不传,不传就传一个NULL)
第三个参数:要调用的函数

dispatch_async_f函数.png

dispatch_async_f的使用.png