GCD基础篇

作者: 哆来 | 来源:发表于2017-03-16 17:52 被阅读9次

1 概要

1.1 简单介绍

GCD是Grand Central Dispatch的简称，它是基于C语言的。如果使用GCD，完全由系统管理线程，我们不需要编写线程代码。只需定义想要执行的任务,然后添加到适当的调度队列(dispatch queue)。GCD会负责创建线程和调度你的任务，系统直接提供线程管理

GCD存在于libdispatch.dylib这个库中，任何IOS程序，默认就加在了这个库，在程序运行的过程中会动态的加载这个库，不需要我们手动导入
GCD是纯C语言的，所以我们在编写GCD代码的时候，面对的是函数，而非方法；
GCD中大多数函数和变量类型都是以dispatch开头的

1.2 重点概念

1.2.1 线程、任务和队列

 <table>
    <tr>
        <td>线程</td>
        <td>程序执行任务的最小调度单位</td>
    </tr>
    <tr>
        <td>任务</td>
        <td>就是一段代码，在GCD总，<b>任务就是block中要执行的内容</b></td>
    </tr>
    <tr>
        <td>队列</td>
        <td>用来存放“任务”的一个数组</td>
    </tr>
</table>

<table>
<tr>
<td>线程</td>
<td>程序执行任务的最小调度单位</td>
</tr>
<tr>
<td>任务</td>
<td>就是一段代码，在GCD总，<b>任务就是block中要执行的内容</b></td>
</tr>
<tr>
<td>队列</td>
<td>用来存放“任务”的一个数组</td>
</tr>
</table>

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

/**
 *  异步执行任务
 *  @param queue     队列
 *  @param block     任务
 */
dispatch_async(dispatch_queue_t  _Nonnull queue, ^(void)block)

/**
 *  同步执行任务
 *  @param queue     队列
 *  @param block     任务
 */
dispatch_sync(dispatch_queue_t  _Nonnull queue, ^(void)block)

1.2.3 特点

<table>
<tr>
<td>异步执行（调度）</td>
<td>具备开线程的能力，<b>任务创建后可以先绕过，回头再执行</b></td>
</tr>
<tr>
<td>同步执行（调度）</td>
<td>不具备开线程的能力，<b>任务创建后就要执行完才能继续往下走</b></td>
</tr>
</table>

1.3 队列

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

并发队列（Concurrent Dispatch Queue）
串行队列（Serial Dispatch Queue）

1.3.1 特点

<table>
<tr>
<td>并行队列</td>
<td>队列中的任务同时执行</td>
</tr>
<tr>
<td>串行队列</td>
<td>队列中的任务要按顺序<b>一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）</b></td>
</tr>
</table>

1.3.2 串行队列

oc提供了两种创建串行队列的方式，一种是手动创建，另一种是获取主队列。

第一种手动创建

dispatch_queue_t dispatch_queue_create(const char *_Nullable label,dispatch_queue_attr_t _Nullable attr);
参数：label 队列标识符（队列名称）
attr 串行队列属性为DISPATCH_QUEUE_SERIAL

【举例】

        
dispatch_queue_t queue = dispatch_queue_create("chrisLiu", NULL); // 创建
    
dispatch_release(queue); // 非ARC需要释放手动创建的队列

第二种获取全局主队列

主队列是GCD自带的一种特殊的串行队列,放在主队列中的任务，<font color=#ff0000>都会放到主线程中执行</font>

dispatch_queue_t dispatch_get_main_queue()

【举例】

dispatch_queue_t queue = dispatch_get_main_queue();

1.3.3 并行队列

并行队列的创建也有两种，一种是手动创建，即（dispatch_queue_create，只不过第二个参数为DISPATCH_QUEUE_CONCURRENT），另一种是获取全局并发队列。
下面主要讲一下如何获得全局的并发队列

dispatch_queue_t dispatch_get_global_queue(dispatch_queue_priority_t priority,unsigned long flags); //

参数：priority 优先级
flags 这个参数是留给以后用的，暂时用不上，传个0。

【说明】 全局并发队列的优先级


#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 queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

1.4 一条重要的准则

一般来说，我们使用GCD的最大目的是在新的线程中同时执行多个任务，这意味着我们需要两项条件：

能开启新的线程
任务可以同时执行
结合以上两个条件，也就等价“开启新线程的能力 + 任务同步执行的权利”，只有在满足能力与权利这两个条件的前提下，我们才可以在同时执行多个任务。

1.5 组合

<tr>
    <td width="20%"></td>
    <td width="26%">并行队列</td>
    <td width="26%">串行队列</td>
    <td width="26%">主队列</td>
</tr>
<tr>
    <td width="20%">异步执行</td>
    <td width="26%">开启多个新的线程，任务同时执行</td>
    <td width="26%">开启一个新的线程，任务按顺序执行</td>
    <td width="26%">不开启新的线程，任务按顺序执行</td>
</tr>
    <tr>
    <td width="20%">同步执行</td>
    <td width="26%">不开启新的线程，任务按顺序执行</td>
    <td width="26%">不开启新的线程，任务按顺序执行</td>
    <td width="26%">死锁</td>
</tr>

</table>

2 代码示例

2.1 异步执行 + 并行队列

//异步执行 + 并行队列
- (void)asyncConcurrent{
    //创建一个并行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"start");
    
    
    dispatch_async(queue, ^{
        sleep(3);
        NSLog(@"任务1---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"任务2---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3---%@", [NSThread currentThread]);
    });
    NSLog(@"end");
}

【说明】 sleep（）；模拟耗时操作

【结果】

3.1.png

【分析】

异步执行意味着
- 可以开启新的线程
- 任务可以先绕过不执行，回头再来执行
并行队列意味着
- 任务之间不需要排队，且具有同时被执行的“权利”
两者组合后的结果
- 开了<=3个的新线程
- 函数在执行时，先打印了start和end，再回头执行这三个任务
- 这三个任务是同时执行的，没有先后，所以打印结果是无序的

2.2 异步执行 + 串行队列

//异步执行 + 串行队列
- (void)asyncSerial{
    //创建一个串行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
    NSLog(@"start");

    dispatch_async(queue, ^{
        sleep(3);
        NSLog(@"任务1---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        sleep(2);
        NSLog(@"任务2---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3---%@", [NSThread currentThread]);
    });

    NSLog(@"end");
}

【结果】

3.2.png

【分析】

异步执行意味着
- 可以开启新的线程
- 任务可以先绕过不执行，回头再来执行
串行队列意味着
- 任务必须按添加进队列的顺序挨个执行
两者组合后的结果
- 开了一个新的子线程
- 函数在执行时，先打印了start和end，再回头执行这三个任务
- 这三个任务是按顺序执行的，所以打印结果是“任务1-->任务2-->任务3”

2.3 同步执行 + 并行队列

//同步执行 + 并行队列
- (void)syncConcurrent{
    //创建一个并行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"start");
    
    dispatch_sync(queue, ^{
        NSLog(@"任务1---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务2---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务3---%@", [NSThread currentThread]);
    });
    
    NSLog(@"end");
}

【结果】

3.3.png

【分析】

同步执行执行意味着
- 不能开启新的线程
- 任务创建后必须执行完才能往下走
并行队列意味着
- 任务之间不需要排队，且具有同时被执行的“权利”
两者组合后的结果
- 所有任务都只能在主线程中执行
- 函数在执行时，必须按照代码的书写顺序一行一行地执行完才能继续
注意事项
- 在这里即便是并行队列，任务可以同时执行，但是由于只存在一个主线程，所以没法把任务分发到不同的线程去同步处理，其结果就是只能在主线程里按顺序挨个挨个执行了

2.4 同步执行 + 串行队列


//同步执行 + 串行队列
- (void)syncSerial{
    //创建一个串行队列
    dispatch_queue_t queue = dispatch_queue_create("标识符", DISPATCH_QUEUE_SERIAL);
    NSLog(@"start");
    
    dispatch_sync(queue, ^{
        NSLog(@"任务1---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务2---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务3---%@", [NSThread currentThread]);
    });
    
    NSLog(@"end");
}

【结果】

14894601899607.jpg

【分析】

这里的执行原理和步骤图跟“同步执行+并发队列”是一样的，只要是同步执行就没法开启新的线程，所以多个任务之间也一样只能按顺序来执行，

2.5 异步执行 + 主队列


//异步执行 + 主队列
- (void)asyncMain{
    dispatch_queue_t queue = dispatch_get_main_queue();
    NSLog(@"start");
    
    dispatch_async(queue, ^{
        NSLog(@"任务1---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2---%@", [NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"任务3---%@", [NSThread currentThread]);
    });
    
    NSLog(@"end");
}

【结果】

WX20170412-150742@2x.png

【分析】

异步执行意味着
- 可以开启新的线程
- 任务可以先绕过不执行，回头再来执行
主队列跟串行队列的区别
- 队列中的任务一样要按顺序执行
- 主队列中的任务必须在主线程中执行，不允许在子线程中执行
以上条件组合后得出结果：
- 所有任务都可以先跳过，之后再来“按顺序”执行

2.6 同步执行 + 主队列


//同步执行 + 主队列
- (void)syncMain{
    dispatch_queue_t queue = dispatch_get_main_queue();
    NSLog(@"start");
    
    dispatch_sync(queue, ^{
        NSLog(@"任务1---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务2---%@", [NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"任务3---%@", [NSThread currentThread]);
    });
    
    NSLog(@"end");
}

【结果】

14894723037449.jpg

【分析】

主队列中的任务必须按顺序挨个执行
任务1要等主线程有空的时候（即主队列中的所有任务执行完）才能执行
主线程要执行完任务1才能继续后续内容
“主线程”和“任务1”互相等待，造成死锁

2.6.1 如何避免上述问题造成的思索

-(void)test2{
    NSLog(@"start");
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"任务1---%@", [NSThread currentThread]);
        });
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"任务2---%@", [NSThread currentThread]);
        });
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"任务3---%@", [NSThread currentThread]);
        });
    });
    NSLog(@"end");
}

【分析】
异步执行意味着可以开启新的线程，任务可以先绕过不执行，回头再来执行，所以等NSLog结束后，主线程就空下来了;这样任务1、任务2、任务3就可以顺序执行下去了，不会造成死锁。

好！再看一个案例

- (void)test3{
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        
        NSLog(@"=================1");
        dispatch_sync(dispatch_get_main_queue(), ^{
            NSLog(@"我不会输出");
        });
        NSLog(@"我也不会输出");
        
    });
    
    NSLog(@"==========我不会阻塞主线程");
    
    while (1) {
    } 
    NSLog(@"==========我会阻塞主线程");
}

【分析】

因为有一个while（1）永真的while语句，所以主线程NSLog(@"==========我会阻塞主线程");永远都不会执行，主线程无法空闲下来，导致dispatch_sync里的block， NSLog(@"我不会输出");永远等待，另外不管是dispatch_async、dispatch_sync，其任务block都是顺序执行的所以NSLog(@"我也不会输出")也不会输出。

GCD基础篇

1 概要

1.1 简单介绍

1.2 重点概念

1.2.1 线程、任务和队列

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

1.2.3 特点

1.3 队列

1.3.1 特点

1.3.2 串行队列

1.3.3 并行队列

1.4 一条重要的准则

1.5 组合

2 代码示例

2.1 异步执行 + 并行队列

2.2 异步执行 + 串行队列

2.3 同步执行 + 并行队列

2.4 同步执行 + 串行队列

2.5 异步执行 + 主队列

2.6 同步执行 + 主队列

2.6.1 如何避免上述问题造成的思索

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读