iOS底层原理:GCD的函数与队列

GCD

简介

  • GCD全称是Grand Central Dispatch
  • 纯C语言,提供例如非常强大的函数

优势

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

【重点】用一句话总结GCD就是:将任务添加到队列,并指定任务执行的函数

核心

在日常开发中,GCD一般写成下面这种形式

 dispatch_async( dispatch_queue_create("com.sunrise.queue", NULL), ^{
   NSLog(@"GCD基本使用");
});

将上述代码拆分,方便我们来理解GCD核心 主要是由 任务 + 队列 + 函数 构成

//********GCD基础写法********
//创建任务
dispatch_block_t block = ^{
    NSLog(@"hello GCD");
};

//创建串行队列
dispatch_queue_t queue = dispatch_queue_create("com.sunrise.queue", NULL);

//将任务添加到队列,并指定函数执行
dispatch_async(queue, block);
  • 使用dispatch_block_t创建任务
  • 使用dispatch_queue_t创建队列
  • 任务添加到队列,并指定执行任务的函数dispatch_async
注意

这里的任务是指执行操作的意思,在使用dispatch_block_t创建任务时,主要有以下两点说明

  • 任务使用block封装
  • 任务的block没有参数没有返回值

函数与队列

函数

在GCD中执行任务的方式有两种,同步执行异步执行,分别对应 同步函数dispatch_sync异步函数dispatch_async,两者对比如下

  • 同步执行,对应同步函数dispatch_sync

    • 必须等待当前语句执行完毕才会执行下一条语句
    • 不会开启线程,即不具备开启新线程的能力
    • 在当前线程中执行block任务
  • 异步执行,对应异步函数dispatch_async

    • 不用等待当前语句执行完毕,就可以执行下一条语句
    • 开启线程执行block任务,即具备开启新线程的能力(但并不一定开启新线程,这个与任务所指定的队列类型有关)
    • 异步多线程 的代名词

所以,综上所述,两种执行方式的主要区别有两点:

  • 是否等待队列的任务执行完毕
  • 是否具备开启新线程的能力

队列

串行队列 和 并发队列

多线程中所说的队列(Dispatch Queue)是指执行任务的等待队列,即用来存放任务的队列。队列是一种特殊的线性表,遵循先进先出(FIFO)原则,即新任务总是被插入到队尾,而任务的读取从队首开始读取。每读取一个任务,则动队列中释放一个任务,如下图所示

队列

在GCD中,队列主要分为串行队列(Serial Dispatch Queue)并发队列(Concurrent Dispatch Queue)两种,如下图所示

串行与并发
  • 串行队列:每次只有一个任务被执行,等待上一个任务执行完毕再执行下一个,即只开启一个线程(通俗理解:同一时刻只调度一个任务执行)
    • 使用dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);创建串行队列
    • 其中的DISPATCH_QUEUE_SERIAL也可以使用NULL表示,这两种均表示 默认的串行队列
// 串行队列的获取方法
dispatch_queue_t serialQueue1 = dispatch_queue_create("com.sunrise.queue", NULL);
dispatch_queue_t serialQueue2 = dispatch_queue_create("com.sunrise.queue", DISPATCH_QUEUE_SERIAL);
  • 并发队列:一次可以并发执行多个任务,即开启多个线程,并同时执行任务(通俗理解:同一时刻可以调度多个任务执行)
    • 使用dispatch_queue_create("xxx", DISPATCH_QUEUE_CONCURRENT);创建并发队列
    • 注意:并发队列的并发功能只有在异步函数下才有效
// 并发队列的获取方法
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.sunrise.queue", DISPATCH_QUEUE_CONCURRENT);

主队列 和 全局并发队列

在GCD中,针对这两种队列,分别提供了主队列(Main Dispatch Queue)全局并发队列(Global Dispatch Queue)

  • 主队列(Main Dispatch Queue):GCD中提供的特殊的串行队列
    • 专门用来 在主线程上调度任务的串行队列,依赖于主线程、主Runloop,在main函数调用之前自动创建
    • 不会开启线程
    • 如果当前主线程正在有任务执行,那么无论主队列中当前被添加了什么任务,都不会被调度
    • 使用dispatch_get_main_queue()获得主队列
    • 通常在返回主线程更新UI时使用
//主队列的获取方法
dispatch_queue_t mainQueue = dispatch_get_main_queue();
  • 全局并发队列(Global Dispatch Queue):GCD提供的默认的并发队列
    • 为了方便程序员的使用,苹果提供了全局队列
    • 在使用多线程开发时,如果对队列没有特殊需求,在执行异步任务时,可以直接使用全局队列
    • 使用dispatch_get_global_queue获取全局并发队列,最简单的是dispatch_get_global_queue(0, 0)
      • 第一个参数表示队列优先级,默认优先级为DISPATCH_QUEUE_PRIORITY_DEFAULT=0,在iOS9之后,已经被服务质量(quality-of-service)取代
      • 第二个参数使用0
//全局并发队列的获取方法
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);

//优先级从高到低(对应的服务质量)依次为
- DISPATCH_QUEUE_PRIORITY_HIGH       -- QOS_CLASS_USER_INITIATED
- DISPATCH_QUEUE_PRIORITY_DEFAULT    -- QOS_CLASS_DEFAULT
- DISPATCH_QUEUE_PRIORITY_LOW        -- QOS_CLASS_UTILITY
- DISPATCH_QUEUE_PRIORITY_BACKGROUND -- QOS_CLASS_BACKGROUND
全局并发队列 + 主队列 配合使用

在日常开发中,全局队列+并发并列一般是这样配合使用的

//主队列 + 全局并发队列的日常使用
dispatch_async(dispatch_get_global_queue(0, 0), ^{
  //执行耗时操作
  dispatch_async(dispatch_get_main_queue(), ^{
     //回到主线程进行UI操作
  });      
});

函数与队列的不同组合

串行队列 + 同步函数

【任务按顺序执行】:任务一个接一个的在当前线程执行,不开辟新线程

串行队列 + 异步函数

【任务按顺序执行】:任务一个接一个的执行,会开辟新线程

并发队列 + 同步函数

【任务按顺序执行】:任务一个接一个的执行,不开辟线程

并发队列 + 异步函数

【任务按乱序执行】:任务执行无顺序,会开辟新线程

主队列 + 同步函数

【造成死锁】:任务相互等待,造成死锁

造成死锁的原因分析如下:

  • 主队列有两个任务,顺序为: NSLog任务 - 同步block
  • 执行NSLog任务后,执行同步Block,会将任务1(即i=1时)加入到主队列,主队列顺序为:NSLog任务 - 同步block - 任务1
  • 任务1的执行需要等待同步block执行完毕才会执行,而同步block的执行需要等待任务1执行完毕,所以就造成了任务互相等待的情况,即造成死锁崩溃
死锁现象
  • 主线程因为同步函数的原因等着先执行任务
  • 主队列等着主线程的任务执行完毕再执行自己的任务
  • 主队列和主线程相互等待会造成死锁

主队列 + 异步函数

【任务按顺序执行】:任务一个接一个的执行,不开辟线程

全局并发队列 + 同步函数

【任务按顺序执行】:任务一个接一个的执行,不开辟新线程

全局并发队列 + 异步函数

【任务按乱序执行】:任务乱序执行,会开辟新线程

总结

函数队列 串行队列 并发队列 主队列 全局并发队列
同步函数 顺序执行,不开辟线程 顺序执行,不开辟线程 死锁 顺序执行,不开辟线程
异步函数 顺序执行,开辟线程 乱序执行,开辟线程 顺序执行,不开辟线程 乱序执行,开辟线程

相关面试题解析

【面试题 - 1】异步函数+并行队列

下面代码的输出顺序是什么?

- (void)interview01{
    //并行队列
    dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    // 耗时
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_async(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}
----------打印结果-----------
输出顺序为:1 5 2 4 3
  • 异步函数不会阻塞主队列,会开辟新线程执行异步任务
代码分析

如下图所示,红线表示任务的执行顺序

  • 主线程的任务队列为:任务1、异步block1、任务5,其中异步block1会比较耗费性能,任务1和任务5的任务复杂度是相同的,所以任务1和任务5优先于异步block1执行

  • 异步block1中,任务队列为:任务2、异步block2、任务4,其中block2相对比较耗费性能,任务2任务4是复杂度一样,所以任务2和任务4优先于block2执行

  • 最后执行block2中的任务3

  • 在极端情况下,可能出现 任务2先于任务1任务5执行,原因是出现了当前主线程卡顿或者延迟的情况

代码修改
  • 【修改1】:将并行队列 改成 串行队列,对结果没有任何影响,顺序仍然是 1 5 2 4 3

  • 【修改2】:在任务5之前,休眠2s,即sleep(2),执行的顺序为:1 2 4 3 5,原因是因为I/O的打印,相比于休眠2s,复杂度更简单,所以异步block1 会先于任务5执行。当然如果主队列堵塞,会出现其他的执行顺序

【面试题 - 2】异步函数嵌套同步函数 + 并发队列

下面代码的输出顺序是什么?

- (void)interview02{
    //并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"1");
    //异步函数
    dispatch_async(queue, ^{
        NSLog(@"2");
        //同步函数
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}

----------打印结果-----------
输出顺序为:1 5 2 3 4
分析
  • 任务1 和 任务5的分析同前面一致,执行顺序为 任务1 任务5 异步block

  • 在异步block中,首先执行 任务2 ,然后走到 同步block ,由于 同步函数会阻塞主线程,所以任务4需要等待任务3执行完成后,才能执行,所以异步block中的执行顺序是:任务2 任务3 任务4

面试题 - 3】异步函数嵌套同步函数 + 串行队列(即同步队列)

下面代码的执行顺序是什么?会出现什么情况?为什么?

- (void)interview03{
    // 同步队列
    dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", NULL);
    NSLog(@"1");
    // 异步函数
    dispatch_async(queue, ^{
        NSLog(@"2");
        // 同步函数
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
        NSLog(@"4");
    });
    NSLog(@"5");
}

----------打印结果-----------
输出顺序为:1 5 2 死锁崩溃
分析

如下图所示,红色表示任务执行顺序,黑色虚线表示等待

  • 首先执行任务1,接下来是异步block,并不会阻塞主线程,相比任务5而言,复杂度更高,所以优先执行任务5,在执行异步block

  • 异步block中,先执行任务2,接下来是同步block,同步函数会阻塞线程,所以执行任务4需要等待任务3执行完成,而任务3的执行,需要等待异步block执行完成,相当于任务3等待任务4完成

  • 所以就造成了任务4等待任务3任务3等待任务4,即互相等待的局面,就会造成死锁,这里有个重点是关键的堆栈 slow

修改

去掉任务4,执行顺序是什么?

  • 还是会死锁,因为任务3等待的是异步block执行完毕而异步block等待任务3

【面试题 - 4 - 新浪】 异步函数 + 同步函数 + 并发队列

下面代码的执行顺序是什么?(答案是 AC)
A: 1230789
B: 1237890
C: 3120798
D: 2137890

- (void)interview04{
    //并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{ // 耗时
        NSLog(@"1");
    });
    dispatch_async(queue, ^{
        NSLog(@"2");
    });
    
    // 同步
    dispatch_sync(queue, ^{
        NSLog(@"3");
    });
    
    NSLog(@"0");

    dispatch_async(queue, ^{
        NSLog(@"7");
    });
    dispatch_async(queue, ^{
        NSLog(@"8");
    });
    dispatch_async(queue, ^{
        NSLog(@"9");
    });
}

----------打印结果-----------
输出顺序为:(1 2 3 无序)0(7 8 9 无序),可以确定的是 0 一定在3之后,在789之前
分析
  • 任务1 和 任务2由于是异步函数+并发队列,会开启线程,所以没有固定顺序

  • 任务7、任务8、任务9同理,会开启线程,所以没有固定顺序

  • 任务3是同步函数+并发队列,同步函数会阻塞主线程,但是也只会阻塞0,所以,可以确定的是 0一定在3之后,在789之前

以下是不同的执行顺序的打印

【面试题 - 5 - 美团】下面代码中,队列的类型有几种

//串行队列 - Serial Dispatch Queue
dispatch_queue_t serialQueue = dispatch_queue_create("com.CJL.Queue", NULL);
    
//并发队列 - Concurrent Dispatch Queue
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.CJL.Queue", DISPATCH_QUEUE_CONCURRENT);
    
//主队列 - Main Dispatch Queue
dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
//全局并发队列 - Global Dispatch Queue
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);

队列总共有两种: 并发队列串行队列

  • 串行队列:serialQueue、mainQueue
  • 并发队列:concurrentQueue、globalQueue

你可能感兴趣的:(iOS底层原理:GCD的函数与队列)