iOS 开发之 GCD 基础

iOS 开发之 GCD 基础

本文主要为 GCD 的 队列和执行方法等基础总结,目录如下:

[TOC]

GCD是什么?

Grand Central Dispatch(GCD) 是 Apple 开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出,也可在 iOS 4 及以上版本使用。

GCD 基本原理 和 优势

GCD 通过提交工作来调度系统管理的队列,在多核硬件上同时执行代码。

GCD 可用于多核的并行运算

GCD 会自动利用更多的 CPU 内核(比如双核、四核)

GCD 会自动管理线程的生命周期(创建线程、调度任务、销毁线程)

程序员只需要告诉 GCD 想要执行什么任务,不需要编写任何线程管理代码

GCD的使用

GCD 中有两个核心概念:任务和队列

任务:就是执行操作的意思,换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式:同步执行(sync)和异步执行(async)。两者的主要区别是:是否等待队列的任务执行结束,以及是否具备开启新线程的能力。

同步执行(sync):

同步添加任务到指定的队列中,在添加的任务执行结束之前,会一直等待,直到队列里面的任务完成之后再继续执行。

只能在当前线程中执行任务,不具备开启新线程的能力。

异步执行(async):

异步添加任务到指定的队列中,它不会做任何等待,可以继续执行任务。

可以在新的线程中执行任务,具备开启新线程的能力。

举个简单例子:你要打电话给小明和小白。

同步执行就是,你打电话给小明的时候,不能同时打给小白,等到给小明打完了,才能打给小白(等待任务执行结束)。而且只能用当前的电话(不具备开启新线程的能力)。

而异步执行就是,你打电话给小明的时候,不等和小明通话结束,还能直接给小白打电话,不用等着和小明通话结束再打(不用等待任务执行结束)。除了当前电话,你还可以使用其他所能使用的电话(具备开启新线程的能力)。

注意: 异步执行(async) 虽然具有开启新线程的能力,但是并不一定开启新线程。这跟任务所指定的队列类型有关。

队列(Dispatch Queue):这里的队列指执行任务的等待队列,即用来存放任务的队列。队列是一种特殊的线性表,采用 FIFO(先进先出)的原则,即新任务总是被插入到队列的末尾,而读取任务的时候总是从队列的头部开始读取。每读取一个任务,则从队列中释放一个任务。队列的结构可参考下

队列示意

在 GCD 中有两种队列:串行队列和并发队列。两者都符合 FIFO(先进先出)的原则。两者的主要区别是:执行顺序不同,以及开启线程数不同。

串行队列(Serial Dispatch Queue):

每次只有一个任务被执行。让任务一个接着一个地执行。(只开启一个线程,一个任务执行完毕后,再执行下一个任务)

并发队列(Concurrent Dispatch Queue):

可以让多个任务并发(同时)执行。(可以开启多个线程,并且同时执行任务)

GCD 的使用步骤

GCD 的使用步骤其实很简单,只有两步。

  • 创建一个队列(串行队列或并发队列)

  • 将任务追加到任务的等待队列中,然后系统就会根据任务类型执行任务(同步执行或异步执行)

下边来看看 队列的创建方法/获取方法,以及 任务的创建方法。

队列的创建方法/获取方法

可以使用 dispatch_queue_create 来创建队列,需要传入两个参数,第一个参数表示队列的唯一标识符,用于 DEBUG,可为空,Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名;第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列,DISPATCH_QUEUE_CONCURRENT 表示并发队列。

串行队列的创建方法

//串行队列
dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_SERIAL);

并发队列的创建方法

// 并发队列
dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_CONCURRENT);

对于串行队列,GCD 提供了的一种特殊的串行队列:主队列(Main Dispatch Queue)

所有放在主队列中的任务,都会放到主线程中执行。

可使用 dispatch_get_main_queue() 获得主队列。

// 主队列
dispatch_queue_t queue = dispatch_get_main_queue();

对于并发队列,GCD 默认提供了全局并发队列(Global Dispatch Queue)

可以使用 dispatch_get_global_queue 来获取。需要传入两个参数。第一个参数表示队列优先级,一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用,用0即可。

// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

第二个参数 flags:文档中描述为保留未来使用,暂时指定为0即可

任务的创建方法

GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async。

// 同步执行任务创建方法
dispatch_sync(queue, ^{

    // 这里放同步执行任务代码

});

// 异步执行任务创建方法
dispatch_async(queue, ^{

    // 这里放异步执行任务代码

});

虽然使用 GCD 只需两步,但是既然我们有两种队列(串行队列/并发队列),两种任务执行方式(同步执行/异步执行),那么我们就有了四种不同的组合方式。这四种不同的组合方式是:

种类 方式
1 同步执行 + 并发队列
2 异步执行 + 并发队列
3 同步执行 + 串行队列
4 异步执行 + 串行队列

实际上,刚才还说了两种特殊队列:全局并发队列、主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊,所以我们就又多了两种组合方式。这样就有六种不同的组合方式了。

种类 方式
5 同步执行 + 主队列
6 异步执行 + 主队列

那么这几种不同组合方式各有什么区别呢,这里为了方便,先上结果,再来讲解。你可以直接查看表格结果,然后跳过 4. GCD 的基本使用 。

区别 并发队列 串行队列 主队列
同步(sync) 不开启新线程,
串行执行任务
不开启新线程,
串行执行任务
不开启新线程,
串行执行任务
异步(async) 开启新线程,
并发执行任务
开启1条新线程,
串行执行任务
不开启新线程,
串行执行任务

下面通过代码来分别验证一下各个组合的使用方法

GCD 各个队列组合的验证

首先是并发队列的两种执行方式。

【并发执行方式1】同步执行 + 并发队列

特点:在当前线程中执行任务,不会开启新线程,执行完一个任务,再执行下一个任务。

/**
 * 同步执行 + 并发队列
 * 特点:在当前线程中执行任务,不会开启新线程,执行完一个任务,再执行下一个任务。
 */

- (void)syncConcurrent {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    
    NSLog(@"syncConcurrent---begin");
    
    // 1. 创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_CONCURRENT);

    // 2. 添加同步任务
    dispatch_sync(queue, ^{
        
        // 追加任务1
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_sync(queue, ^{

        // 追加任务2
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });


    dispatch_sync(queue, ^{
    
        // 追加任务3
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"syncConcurrent---end");
}


------------------输出结果----------------

currentThread---{number = 1, name = main}
syncConcurrent---begin
1---{number = 1, name = main}
1---{number = 1, name = main}
2---{number = 1, name = main}
2---{number = 1, name = main}
3---{number = 1, name = main}
3---{number = 1, name = main}
syncConcurrent---end

------------------输出结果----------------

从同步执行 + 并发队列中可看到:

所有任务都是在当前线程(主线程)中执行的,没有开启新的线程(同步执行不具备开启新线程的能力)。

所有任务都在打印的syncConcurrent---begin和syncConcurrent---end之间执行的(同步任务需要等待队列的任务执行结束)。

任务按顺序执行的。按顺序执行的原因:虽然并发队列可以开启多个线程,并且同时执行多个任务。但是因为本身不能创建新线程,只有当前线程这一个线程(同步任务不具备开启新线程的能力),所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后,才能继续接着执行下面的操作(同步任务需要等待队列的任务执行结束)。所以任务只能一个接一个按顺序执行,不能同时被执行。

【并发执行方式2】异步执行 + 并发队列

特点:可以开启多个线程,任务交替(同时)执行。

/**
 * 异步执行 + 并发队列
 * 特点:可以开启多个线程,任务交替(同时)执行。
 */

- (void)asyncConcurrent {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    
    NSLog(@"asyncConcurrent---begin");
    
    // 1. 创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_CONCURRENT);

    // 2. 添加异步任务
    dispatch_async(queue, ^{
        
        // 追加任务1
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_async(queue, ^{

        // 追加任务2
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });


    dispatch_async(queue, ^{
    
        // 追加任务3
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"asyncConcurrent---end");
}


------------------输出结果----------------

currentThread---{number = 1, name = main}
asyncConcurrent---begin
asyncConcurrent---end
2---{number = 5, name = (null)}
3---{number = 4, name = (null)}
1---{number = 3, name = (null)}
3---{number = 4, name = (null)}
1---{number = 3, name = (null)}
2---{number = 5, name = (null)}
------------------输出结果----------------

在异步执行 + 并发队列中可以看出:

除了当前线程(主线程),系统又开启了3个线程,并且任务是交替/同时执行的。(异步执行具备开启新线程的能力。且并发队列可开启多个线程,同时执行多个任务)。

所有任务是在打印的asyncConcurrent---begin和asyncConcurrent---end之后才执行的。说明当前线程没有等待,而是直接开启了新线程,在新线程中执行任务(异步执行不做等待,可以继续执行任务)。

还能按到一点:当某个异步队列中添加并发任务后,所有需要执行的任务都会在其开辟的一条新线程中执行。新开辟的线程是并发执行的,但上面的任务是按序执行的

接下来再来讲讲串行队列的两种执行方式。

【串行执行方式1】同步执行 + 串行队列

特点:不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务。

/**
 * 同步执行 + 串行队列
 * 特点:不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务。
 */

- (void)syncSerial {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    
    NSLog(@"syncSerial---begin");
    
    // 1. 创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_SERIAL);

    // 2. 添加异步任务
    dispatch_sync(queue, ^{
        
        // 追加任务1
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_sync(queue, ^{

        // 追加任务2
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });


    dispatch_sync(queue, ^{
    
        // 追加任务3
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"syncSerial---end");
}


------------------输出结果----------------

currentThread---{number = 1, name = main}
syncSerial---begin
1---{number = 1, name = main}
1---{number = 1, name = main}
2---{number = 1, name = main}
2---{number = 1, name = main}
3---{number = 1, name = main}
3---{number = 1, name = main}
syncSerial---end
------------------输出结果----------------

在同步执行 + 串行队列可以看到:

所有任务都是在当前线程(主线程)中执行的,并没有开启新的线程(同步执行不具备开启新线程的能力)。

所有任务都在打印的syncSerial---begin和syncSerial---end之间执行(同步任务需要等待队列的任务执行结束)。

任务是按顺序执行的(串行队列每次只有一个任务被执行,任务一个接一个按顺序执行)。

【串行执行方式2】异步执行 + 串行队列

特点:会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务

/**
 * 异步执行 + 串行队列
 * 特点:会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务
 */

- (void)asyncSerial {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    
    NSLog(@"asyncSerial---begin");
    
    // 1. 创建并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_SERIAL);

    // 2. 添加异步任务
    dispatch_async(queue, ^{
        
        // 追加任务1
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_async(queue, ^{

        // 追加任务2
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });


    dispatch_async(queue, ^{
    
        // 追加任务3
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"asyncSerial---end");
}


------------------输出结果----------------

currentThread---{number = 1, name = main}
asyncSerial---begin
asyncSerial---end
1---{number = 3, name = (null)}
1---{number = 3, name = (null)}
2---{number = 3, name = (null)}
2---{number = 3, name = (null)}
3---{number = 3, name = (null)}
3---{number = 3, name = (null)}
------------------输出结果----------------

在异步执行 + 串行队列可以看到:

开启了一条新线程(异步执行具备开启新线程的能力,串行队列只开启一个线程)。

所有任务是在打印的asyncSerial---begin和asyncSerial---end之后才开始执行的(异步执行不会做任何等待,可以继续执行任务)。

任务是按顺序执行的(串行队列每次只有一个任务被执行,任务一个接一个按顺序执行)。

下边讲讲刚才我们提到过的特殊队列:主队列。

主队列:GCD自带的一种特殊的串行队列

所有放在主队列中的任务,都会放到主线程中执行

可使用dispatch_get_main_queue()获得主队列

我们再来看看主队列的两种组合方式。

【主队列1】同步执行 + 主队列

同步执行 + 主队列在不同线程中调用结果也是不一样,在主线程中调用会出现死锁,而在其他线程中则不会。

在主线程中调用同步执行 + 主队列

特点:互相等待卡住不可行

/**
 * 同步执行 + 主队列
 * 特点(主线程调用):互等卡主不执行。
 * 特点(其他线程调用):不会开启新线程,执行完一个任务,再执行下一个任务。
 */
- (void)syncMain {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"syncMain---begin");
    
    // 1.获取主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    // 2.添加同步任务
    dispatch_sync(queue, ^{

        // 追加任务1
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_sync(queue, ^{
        // 追加任务2
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    dispatch_sync(queue, ^{
        // 追加任务3
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });
    
    NSLog(@"syncMain---end");
}

------------------输出结果----------------

currentThread---{number = 1, name = main}
syncMain---begin
(lldb)

------------------输出结果----------------

在同步执行 + 主队列可以惊奇的发现:

在主线程中使用同步执行 + 主队列,追加到主线程的任务1、任务2、任务3都不再执行了,而且syncMain---end也没有打印,在XCode 9上还会报崩溃。这是为什么呢?

这是因为我们在主线程中执行syncMain方法,相当于把syncMain任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕,才会接着执行。那么当我们把任务1追加到主队列中,任务1就在等待主线程处理完syncMain任务。而syncMain任务需要等待任务1执行完毕,才能接着执行。

那么,现在的情况就是syncMain任务和任务1都在等对方执行完毕。这样大家互相等待,所以就卡住了,所以我们的任务执行不了,而且syncMain---end也没有打印。

要是如果不在主线程中调用,而在其他线程中调用会如何呢?

在其他线程中调用同步执行 + 主队列

特点:不会开启新线程,执行完一个任务,再执行下一个任务

还是上面代码,我们使用 NSThread 的 detachNewThreadSelector 方法会创建线程,并自动启动线程执行 selector 任务

// 新建线程执行 syncMain 方法
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];


------------------输出结果----------------
currentThread---{number = 3, name = (null)}
syncMain---begin
1---{number = 1, name = main}
1---{number = 1, name = main}
2---{number = 1, name = main}
2---{number = 1, name = main}
3---{number = 1, name = main}
3---{number = 1, name = main}
syncMain---end
------------------输出结果----------------

在其他线程中使用同步执行 + 主队列可看到:

所有任务都是在主线程(非当前线程)中执行的,没有开启新的线程(所有放在主队列中的任务,都会放到主线程中执行)。

所有任务都在打印的syncMain---begin和syncMain---end之间执行(同步任务需要等待队列的任务执行结束)。

任务是按顺序执行的(主队列是串行队列,每次只有一个任务被执行,任务一个接一个按顺序执行)。

为什么现在就不会卡住了呢?

因为syncMain 任务放到了其他线程里,而任务1、任务2、任务3都在追加到主队列中,这三个任务都会在主线程中执行。syncMain 任务在其他线程中执行到追加任务1到主队列中,因为主队列现在没有正在执行的任务,所以,会直接执行主队列的任务1,等任务1执行完毕,再接着执行任务2、任务3。所以这里不会卡住线程。

【主队列2】异步执行 + 主队列

特点:特点:只在主线程中执行任务,执行完一个任务,再执行下一个任务

/**
 * 异步执行 + 主队列
 * 特点:只在主线程中执行任务,执行完一个任务,再执行下一个任务
 */
- (void)asyncMain {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  // 打印当前线程
    NSLog(@"asyncMain---begin");

    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_async(queue, ^{

        // 追加任务1
        for(int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });



    dispatch_async(queue, ^{
        // 追加任务2
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        }

    });



    dispatch_async(queue, ^{
        // 追加任务3
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"3---%@",[NSThread currentThread]);      // 打印当前线程
        }
    });

    NSLog(@"asyncMain---end");
}

------------------输出结果----------------
currentThread---{number = 3, name = (null)}
asyncMain---begin
1---{number = 1, name = main}
1---{number = 1, name = main}
2---{number = 1, name = main}
2---{number = 1, name = main}
3---{number = 1, name = main}
3---{number = 1, name = main}
asyncMain---end
------------------输出结果----------------

在异步执行 + 主队列可以看到:

所有任务都是在当前线程(主线程)中执行的,并没有开启新的线程(虽然异步执行具备开启线程的能力,但因为是主队列,所以所有任务都在主线程中)。

所有任务是在打印的syncConcurrent---begin和syncConcurrent---end之后才开始执行的(异步执行不会做任何等待,可以继续执行任务)。

任务是按顺序执行的(因为主队列是串行队列,每次只有一个任务被执行,任务一个接一个按顺序执行)。

弄懂了难理解、绕来绕去的队列+任务之后,我们来学习一个简单的东西:GCD 线程间的通信。

GCD 线程间的通信

在 iOS 开发过程中,我们一般在主线程里边进行 UI 刷新,例如:点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程,比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时,需要回到主线程,那么就用到了线程之间的通讯。

/**
 * 线程间通信
 */

- (void)communication {

    // 获取全局并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

    // 获取主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue(); 

    dispatch_async(queue, ^{

        // 异步追加任务
        for(inti = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }

        // 回到主线程
        dispatch_async(mainQueue, ^{
            // 追加在主线程中执行的任务
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        });
    });
}

------------------输出结果----------------
1---{number = 3, name = (null)}
1---{number = 3, name = (null)}
2---{number = 1, name = main}
------------------输出结果----------------

可以看到在其他线程中先执行任务,执行完了之后回到主线程执行主线程的相应操作。

小结

本文到此总结了 GCD 一些基本知识 和 【队列】+【任务】的各种组合与关系。
后面会总结一些 GCD 在实际场景中不同用法。

欢迎继续阅读后续文章

推荐阅读更多精彩内容