GCD队列和调度组

GCD的队列可以分为2大类型，分别为串行队列和并发队列
     串行队列（Serial Dispatch Queue）：
     一次只调度一个任务，队列中的任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
     创建一个队列
     dispatch_queue_t q = dispatch_queue_create(const char *label, dispatch_queue_attr_t attr)
     参数：
  const char *label：队列的名称
  dispatch_queue_attr_t attr：队列的属性，属性有两个，分别为：
     DISPATCH_QUEUE_SERIAL(NULL)   串行队列
     DISPATCH_QUEUE_CONCURRENT     并发队列

队列属性为宏，其中串行队列的宏值为NULL，所以创建一个串行队列可以用如下代码

dispatch_queue_t q = dispatch_queue_create(“chuanXing", NULL);

一个串行的异步任务演示如下

  // 1. 串行队列

    // 下面两种写法是一样的

//    dispatch_queue_t queue = dispatch_queue_create("testSer", DISPATCH_QUEUE_SERIAL);

    dispatch_queue_t queue = dispatch_queue_create("testSer", NULL);

    // 2. 串行队列,异步执行

串行队列：一个一个执行

异步执行：肯定会开新线程，在新线程执行

结果：只会开一个线程，而且所有任务都在这个新的线程里面执行

    for (int i = 0; i < 10; i++) {

        dispatch_async(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

    }

    NSLog(@"最后---%@",[NSThread currentThread]);

执行结果如下

 3.串行队列,同步任务

串行队列：顺序，一个一个执行

同步任务：不会开辟新线程，是在当前线程执行

结果：不开新线程，在当前线程顺序执行

dispatch : 调度，GCD里面函数，都是以dispatch开头的

// 1. 创建一个串行队列

    //参数：1. 队列标签 2. 队列的属性

    dispatch_queue_t queue = dispatch_queue_create("testSer", DISPATCH_QUEUE_SERIAL);

    NSLog(@"开始!!");

    // 2. 同步执行任务

    // 一般只要使用”同步“执行，串行队列对添加的同步任务，会立马执行

    dispatch_sync(queue, ^{

        NSLog(@"%@", [NSThread currentThread]);

    });

        NSLog(@"完成!!");

 4.自己创建一个并发队列，异步执行

并发队列：可以同时执行多个任务

异步执行：会开新线程，在新线程执行

结果：会开很多个线程，同时执行

//1. 并行队列

    dispatch_queue_t queue = dispatch_queue_create("cz", DISPATCH_QUEUE_CONCURRENT);

    

    // 2. 异步执行任务

    for (int i = 0; i < 10; i++) {

        dispatch_async(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

    }

       

       NSLog(@"最后");

 

5.并发队列,同步任务

  并发队列：可以同时执行多个任务

  同步任务：不会开辟新线程，是在当前线程执行

  结果：不开新线程，顺序一个一个执行。

 

NSLog(@"----1");

    //1. 并行队列

    dispatch_queue_t queue = dispatch_queue_create("cz", DISPATCH_QUEUE_CONCURRENT);

    

    // 2. 同步执行任务

    for (int i = 0; i < 10; i++) {

        dispatch_sync(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

    }

    NSLog(@"----2");

 6.主队列,异步执行

主队列：专门负责在主线程上调度任务，不会在子线程调度任务，在主队列不允许开新线程.

结果: 不开线程， 只能在主线程上面，顺序执行!

// 1. 获得主队列-> 程序启动，--> 至少有一个主线程-> 一开始就会创建主队列

    dispatch_queue_t queue = dispatch_get_main_queue();

    

    NSLog(@"1----");

    

    // 2. 异步执行任务

    for (int i = 0; i < 10; i++) {

        NSLog(@"调度前---");

        // 异步：把任务放到主队列里，但是不需要马上执行

        dispatch_async(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

        NSLog(@"睡会");

        [NSThread sleepForTimeInterval:2.0];

    }

    NSLog(@"完成----");

 7.主队列同步执行

主队列：专门负责在主线程上调度任务，不会在子线程调度任务，在主队列不允许开新线程.

  同步执行：要马上执行

  结果：死锁

 

// 1. 获得主队列-> 程序启动，--> 至少有一个主线程-> 一开始就会创建主队列

    dispatch_queue_t queue = dispatch_get_main_queue();

    

    NSLog(@"1----");

    

    // 2. 同步执行任务

    for (int i = 0; i < 10; i++) {

        NSLog(@"调度前---");

        // 同步：把任务放到主队列里，但需是马上执行

        dispatch_sync(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

        NSLog(@"睡会");

        [NSThread sleepForTimeInterval:2.0];

    }

    NSLog(@"完成----");

 7.全局队列异步执行任务

// 获得全局队列

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    // 添加异步任务

    for (int i = 0; i < 10; i++) {

        dispatch_async(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

    }

    NSLog(@"完成----");

 8.全局队列同步执行任务

// 获得全局队列

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    // 添加同步任务

    for (int i = 0; i < 10; i++) {

        dispatch_sync(queue, ^{

            NSLog(@"%@ %d", [NSThread currentThread], i);

        });

    }

    NSLog(@"完成----");

 

/**

全局队列跟并发队列的区别

1. 全局队列没有名称 并发队列有名称

2. 全局队列，是供所有的应用程序共享。

3. 在MRC开发，并发队列，创建完了，需要释放。 全局队列不需要我们管理

*/

二，并发队列和串行队列总结

// 核心概念：

// 任务：block

// 队列：把任务放到队列里面，队列先进先出FIFO的原则，

// 串行队列：顺序，一个一个执行(必须一个任务执行完了，才能从队列里面取出下一个任务)

// 并发队列：同时，同时执行很多个任务（可以同时取出很多个任务，只要有线程去执行）

// 同步sync：不会开新线程

// 异步async：会开新线程，多线程的代名词

// 串行队列同步执行：不开线程，在原来线程里面一个一个顺序执行

// 串行队列异步执行：开一条线程，在这个新线程里面一个一个顺序执行

// 并发队列异步执行：开多个线程，并发执行（不一定是一个一个）执行

// 并发队列同步执行：不开线程，在原来线程里面一个一个顺序执行

// 阶段性总结：

// 1. 开不开线程，由执行任务方法决定，同步不开线程，异步肯定开线程

// 2. 开多少线程，由队列决定，串行 最多 开一个线程， 并发可以开多个线程。 具体开多少个，有GCD底层决定，程序猿不能控制

9.有一个小说网站必须登录，才能下载小说

// 并发队列

    dispatch_queue_t  queue = dispatch_queue_create("cz", DISPATCH_QUEUE_CONCURRENT);

    

    /**

     例子：有一个小说网站

     - 必须登录，才能下载小说

     

     有三个任务：

     1. 用户登录

     2. 下载小说A

     3. 下载小说B

     */

    // 添加任务

    // 同步任务，需要马上执行。 不开新线程

    dispatch_sync(queue, ^{

        NSLog(@"用户登录 %@", [NSThread currentThread]);

    });

    //

    dispatch_async(queue, ^{

        NSLog(@"下载小说A %@", [NSThread currentThread]);

    });

    dispatch_async(queue, ^{

        NSLog(@"下载小说B %@", [NSThread currentThread]);

    });

 GCD调度组

有这么一个需要，分别执行2个耗时的异步操作，等2个异步操作都执行完毕后在回到主线程执行操作。如果想要快速高效地实现这个需求，可以考虑使用调度组。

调度组的创建代码如下

dispatch_group_t group = dispatch_group_create();

往调度组里面添加任务的函数如下

dispatch_group_async(dispatch_group_t group, dispatch_queue_t queue, ^(void)block)

第一个参数group是一个调度组，queue是一个异步队列，这里如果使用同步队列意义就不大了，不过还是能达到效果，第三个参数是一个执行代码块，任务都添加到该代码块里面。

往调度组里面添加任务并获得通知的代码如下：

//  群组－统一监控一组任务
    dispatch_group_t group = dispatch_group_create();
   
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    // 添加任务
    // group 负责监控任务，queue 负责调度任务
    dispatch_group_async(group, q, ^{
        [NSThread sleepForTimeInterval:1.0];
        NSLog(@"任务1 %@", [NSThread currentThread]);
    });
    dispatch_group_async(group, q, ^{
        NSLog(@"任务2 %@", [NSThread currentThread]);
    });
    dispatch_group_async(group, q, ^{
        NSLog(@"任务3 %@", [NSThread currentThread]);
    });
  
    // 监听所有任务完成 － 等到 group 中的所有任务执行完毕后，"由队列调度 block 中的任务异步执行！"
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 修改为主队列，后台批量下载，结束后，主线程统一更新UI
        NSLog(@"OK %@", [NSThread currentThread]);
    });
   

NSLog(@"come here");

 

GCD调度组中还有一个添加任务的函数：

dispatch_group_enter(dispatch_group_t group)

dispatch_group_leave(dispatch_group_t group)

这两个函数要配对出现

例如：

// 群组－统一监控一组任务
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_queue_t q = dispatch_get_global_queue(0, 0);
    
    // 1> 入组 -> 之后的 block 会被 group 监听
    // dispatch_group_enter 一定和 dispatch_group_leave 要配对出现
    dispatch_group_enter(group);
    dispatch_async(q, ^{
        NSLog(@"task1 %@", [NSThread currentThread]);
        
        // block 的末尾，所有任务执行完毕后，添加一个出组
        dispatch_group_leave(group);
    });
 
    //  再次入组
    dispatch_group_enter(group);
    dispatch_async(q, ^{
        [NSThread sleepForTimeInterval:1.0];
        
        NSLog(@"task2 %@", [NSThread currentThread]);
        
        // block 的末尾，所有任务执行完毕后，添加一个出组
        dispatch_group_leave(group);
    });
   
    // 群组结束
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"OVER");
    });  

NSLog(@"come here");

 代码执行的效果与刚才那种方式相同！
GCD中还有一个函数
dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout)
该函数是个阻塞式的等待，当我们将第二个参数设置为DISPATCH_TIME_FOREVER时，群组任务不执行完，后续代码就会无法执行，也就是说只要任务不执行完come here就不会打印。

参考：
ios多线程操作（五）—— GCD串行队列与并发队列_爱家人，爱老婆，爱生活，爱coding，爱运动的有爱青年-CSDN博客ios多线程操作（八）—— GCD调度组_爱家人，爱老婆，爱生活，爱coding，爱运动的有爱青年-CSDN博客GCD实践——串行队列/并发队列与iOS多线程详解_乞力马扎罗的雪CYF的博客-CSDN博客