1.多线程中的的一些基本概念

进程：对于操作系统来说，一个可以运行的应用程序（app）就是一个进程。
线程：一个app中可能会同时处理不同的任务，比如请求数据和页面刷新，请求数据会在子线程处理，页面刷新会在主线程处理，一个程序中可以有多个线程。
队列：在GCD中的队列就是指用来存放任务的等待队列，把任务添加到队列后，我们不需要跟线程打交道。GCD在后段管理着一个线程池。
队列可以分为串行队列和并发队列。
串行队列：在这个队列中的任务会按照FIFO一个一个执行，只会开启一个线程。
并发队列：这个队列中的任务会按照FIFO出来，但是会同时开辟多个线程执行。
主队列：是一个全局可用的串行队列。
全局队列：一个全局可用的并发队列。

同步执行（dispatch_sync）：同步执行就是指使用 dispatch_sync方法将任务同步的添加到队列里，在添加的任务执行结束之前，当前线程会被阻塞，然后会一直等待，直到任务完成。
dispatch_sync添加的任务只能在当前线程执行，不具备开启新线程的能力

异步执行（dispatch_async）:异步执行就是指使用dispatch_async方法将任务异步的添加到队列里，它不需要等待任务执行结束，不需要做任何等待就能继续执行任务
dispatch_async添加的任务可以在新的线程中执行任务，具备开启新线程的能力，但并不一定会开启新线程

2.不同队列对应同步异步执行的情况

2.1 同步执行主队列中的任务

2.1.1在主线程中同步执行主队列的任务

dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"在主线程同步添加主队列任务");
    });

运行结果卡死，GCD-主线程上同步执行主队列任务卡死

2.1.2在子线程中同步执行主队列任务

NSLog(@"进入子线程之前,当前线程：%@", [NSThread currentThread]);
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"进入子线程,当前线程：%@", [NSThread currentThread]);
        for (int i = 0; i < 10; i++) {
            dispatch_sync(dispatch_get_main_queue(), ^{
                NSLog(@"在子线程中开启的主队列同步任务i=%d,当前线程：%@", i, [NSThread currentThread]);
            });
        }
        NSLog(@"子线程中的主队列任务已经完成,当前线程：%@", [NSThread currentThread]);
    });
    NSLog(@"子线程代码已经结束,当前线程：%@", [NSThread currentThread]);

运行结果:主队列中的任务在主线程按顺序执行。主队列中的任务等主线程执行完再执行。

2.2异步执行主队列的任务

2.2.1在主线程中异步执行主队列的任务

NSLog(@"主队列任务添加前");
        for (int i = 0; i < 10; i++) {
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"在子线程中开启的主队列异步任务i=%d,当前线程：%@", i, [NSThread currentThread]);
            });
        }
    NSLog(@"主队列任务添加后");

运行结果：

主队列任务添加前
主队列任务添加后
在子线程中开启的主队列异步任务i=0,当前线程：<NSThread: 0x600000795480>{number = 1, name = main}
在子线程中开启的主队列异步任务i=1,当前线程：<NSThread: 0x600000795480>{number = 1, name = main}
······
在子线程中开启的主队列异步任务i=9,当前线程：<NSThread: 0x600000795480>{number = 1, name = main}

先执行主队列之外主线程中的代码，然后按顺序在主线程执行主队列中的任务。

2.2.2在子线程中异步执行主队列的任务

NSLog(@"进入子线程之前,当前线程：%@", [NSThread currentThread]);
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"进入子线程,当前线程：%@", [NSThread currentThread]);
        for (int i = 0; i < 10; i++) {
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"在子线程中开启的主队列异步任务i=%d,当前线程：%@", i, [NSThread currentThread]);
            });
        }
        NSLog(@"子线程中的主队列任务已经完成,当前线程：%@", [NSThread currentThread]);
    });
    NSLog(@"子线程代码已经结束,当前线程：%@", [NSThread currentThread]);

运行结果：先执行主队列之外主线程中的代码，然后按顺序在主线程执行主队列中的任务。
2.3串行队列同步执行

dispatch_queue_t queue = dispatch_queue_create("testSerialSync", DISPATCH_QUEUE_SERIAL);
    NSLog(@"当前线程为%@", [NSThread currentThread]);
    for (int i = 0; i < 10; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"i = %d,当前线程为%@", i, [NSThread currentThread]);
        });
    }
    for (int j = 0; j < 10; j++) {
        NSLog(@"j = %d, 当前线程为%@", j, [NSThread currentThread]);
    }

结果：不开辟子线程，在主线程按顺序执行。主线程中的代码会等串行队列中的任务结束后在执行。
2.4串行队列异步执行

dispatch_queue_t queue = dispatch_queue_create("testSerialSync", DISPATCH_QUEUE_SERIAL);
    NSLog(@"当前线程为%@", [NSThread currentThread]);
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            NSLog(@"i = %d,当前线程为%@", i, [NSThread currentThread]);
        });
    }
    for (int j = 0; j < 10; j++) {
        NSLog(@"j = %d, 当前线程为%@", j, [NSThread currentThread]);
    }

结果：开辟一个子线程，同步队列中的任务在子线程按顺序执行。主线程的代码会和串行队列中的任务同时执行。
2.5并发队列同步执行

dispatch_queue_t queue = dispatch_queue_create("testSerialSync", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"当前线程为%@", [NSThread currentThread]);
    for (int i = 0; i < 10; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"i = %d,当前线程为%@", i, [NSThread currentThread]);
        });
    }
    for (int j = 0; j < 10; j++) {
        NSLog(@"j = %d, 当前线程为%@", j, [NSThread currentThread]);
    }
结果：不开辟子线程，在主线程中按顺序执行，主线程中的任务等并发队列中的任务执行完再执行。

2.6并发队列异步执行

dispatch_queue_t queue = dispatch_queue_create("testSerialSync", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"当前线程为%@", [NSThread currentThread]);
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            NSLog(@"i = %d,当前线程为%@", i, [NSThread currentThread]);
        });
    }
    NSLog(@"当前线程为%@", [NSThread currentThread]);

结果：开辟多个线程，和主线程之后的代码同时执行，主线程按顺序执行。
总结：
在主线程中同步执行主队列的任务：卡死

在子线程中同步执行主队列任务：主队列中的任务在主线程按顺序执行。主队列中的任务等主线程之后的代码执行完再执行。

在主线程中异步执行主队列的任务：先执行主队列之外主线程中的代码，然后按顺序在主线程执行主队列中的任务。

在子线程中异步执行主队列的任务：先执行主队列之外主线程中的代码，然后按顺序在主线程执行主队列中的任务。

串行队列同步执行：不开辟子线程，在主线程按顺序执行。主线程中的代码会等串行队列中的任务结束后在执行。

串行队列异步执行：开辟一个子线程，同步队列中的任务在子线程按顺序执行。主线程的代码会和串行队列中的任务同时执行。

并发队列同步执行：不开辟子线程，在主线程中按顺序执行，主线程中的任务等并发队列中的任务执行完再执行。

并发队列异步执行：开辟多个线程，和主线程之后的代码同时执行，主线程按顺序执行。

3.队列的挂起和恢复

挂起指定队列：dispatch_suspend(queue);
恢复指定队列：dispatchp_resume(queue);
示例：

dispatch_queue_t queue = dispatch_queue_create("queueSuspend", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(queue, ^{
        NSLog(@"队列没有挂起前添加的任务开始执行");
        sleep(3);
        NSLog(@"队列没有挂起前添加的任务执行结束");
    });
    NSLog(@"队列还没有挂起");
    dispatch_suspend(queue);
    NSLog(@"队列已经挂起");
    dispatch_async(queue, ^{
        NSLog(@"队列被挂起之后添加的任务开始执行");
    });
    NSLog(@"5秒后恢复队列");
    sleep(5);
    dispatch_resume(queue);
    NSLog(@"队列已经恢复");

打印结果：

2020-02-28 15:52:12.132254+0800 Test[23449:1607212] 队列还没有挂起
2020-02-28 15:52:12.132259+0800 Test[23449:1607343] 队列没有挂起前添加的任务开始执行
2020-02-28 15:52:12.132424+0800 Test[23449:1607212] 队列已经挂起
2020-02-28 15:52:12.132525+0800 Test[23449:1607212] 5秒后恢复队列
2020-02-28 15:52:15.136284+0800 Test[23449:1607343] 队列没有挂起前添加的任务执行结束
2020-02-28 15:52:17.132924+0800 Test[23449:1607212] 队列已经恢复
2020-02-28 15:52:17.132924+0800 Test[23449:1607343] 队列被挂起之后添加的任务开始执行

由结果可以知道，dispatch_suspend函数可以挂起队列，dispatch_resume函数可以恢复队列，
队列挂起后不会马上停止当前在执行的任务，而是会执行完当前的任务，暂停后面队列中的任务。

4.GCD的延时函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (3)( * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
代码块
});
这个代码的意思是在当前时间的3秒后在主队列执行相应的代码块。

5.GCD取消任务执行

5.1 iOS8之后可以调用dispatch_block_cancel来取消

5.2定义外部变量，用于标记block是否需要取消

GCD取消任务执行

GCD-基本概念以及队列和同步异步组合后的情况