• 并行和并发
• GCD简介
• GCD的任务
• GCD的队列
• GCD创建队列或获取队列的方法
• 任务的执行方式：同步执行（同步）和异步执行（异步）
• GCD提交执行任务的具体方法
• 1.异步执行一个并发队列
• 2.异步执行一个串行队列（非主队列）
• 3.同步执行串行队列（非主队列）
• 4.同步执行并发队列
• 5.异步执行主队列（在主线程中）
• 6.同步执行主队列（在主线程中）

本文参考文章链接：

• 巧谈GCD
• iOS多线程详解
• iOS多线程——你要知道的GCD都在这里（这篇存在着一些错误，慎读）

前言

• 这是GCD系列的第一篇，写的基础东西比较多，所以文章较长，可以按照目录分段来看。

• 可能会存在理解不到位的情况及书写纰漏，烦请指出，谢谢。

• 对你有帮助的话，请点个喜欢或留言，谢谢。>_<

GCD1之综合理解

并行和并发

并发表示同时发生了多件事情，通过时间片切换，哪怕只有单一的核心，也可以实现“同时做多件事情”这个效果。根据底层是否有多处理器，并发与并行是可以等效的，这并不是两个互斥的概念。举个我们开发中会遇到的例子，我们说资源请求并发数达到了1万。这里的意思是有1万个请求同时过来了。但是这里很明显不可能真正的同时去处理这1万个请求的吧！如果这台机器的处理器有4个核心，不考虑超线程，那么我们认为同时会有4个线程在跑。也就是说，并发访问数是1万，而底层真实的并行处理的请求数是4。如果并发数小一些只有4的话，又或者你的机器牛逼有1万个核心，那并发在这里和并行一个效果。也就是说，并发可以是虚拟的同时执行，也可以是真的同时执行。而并行的意思是真的同时执行。结论是：并行是我们物理时空观下的同时执行，而并发则是操作系统用线程这个模型抽象之后站在线程的视角上看到的“同时”执行。

并发是逻辑上的同时发生，并行更多是侧重于物理上的同时发生。并发往往是指程序代码的结构支持并发，并发的程序在多cpu上运行起来才有可能达到并行，并行往往是描述运行时的状态。

GCD简介

1. GCD全称Grand Central Dispatch是苹果提供的一个多核编程的解决方案，在真正意义上实现了并行操作，而不是并发。GCD使用线程池模型来执行用户提交的任务，所以它比较节约资源，不需要为每个任务都重新创建一个新的线程，GCD不需要自行编写并行代码，而是自动进行多核的并行计算，自动管理线程的生命周期，如:使用线程池管理线程的创建和销毁，线程的调度，任务的调度等，用户只需要编写任务代码并提交即可。

2. GCD（Grand Central Dispatch）伟大的中央调度系统，是苹果为多核并行运算提出的C语言并发技术框架。

• GCD会自动利用更多的CPU内核；
• 会自动管理线程的生命周期（创建线程，调度任务，销毁线程等）；
• 程序员只需要告诉 GCD 想要如何执行什么任务，不需要编写任何线程管理代码。

1. 一些专业术语

• dispatch :派遣/调度

• queue:队列
  用来存放任务的先进先出（FIFO）的容器

• sync:同步
  只是在当前线程中执行任务，不具备开启新线程的能力

• async:异步
  可以在新的线程中执行任务，具备开启新线程的能力

• concurrent:并发
  多个任务并发（同时）执行

• serial:串行
  一个任务执行完毕后，再执行下一个任务

1. GCD中有两个比较重要的概念:任务和队列。

GCD的任务

任务顾名思义就是我们需要执行的代码块，可以是一个方法也可以是一个block，就是我们需要线程为我们完成的工作，编写完成的任务只需提交给GCD的队列，即可自动帮我们完成任务的调度，以及线程的调度，可以很方便的以多线程的方式执行。

GCD的队列

队列用于管理用户提交的任务，GCD的队列有两种形式，串行队列和并发队列:

• 串行队列: GCD底层只维护一个线程，任务只能串行依次执行。
• 并发队列: GCD底层使用线程池维护多个线程，任务可并发执行。

不论是串行队列还是并发队列都使用 先进先出（FIFO，First Input First Output） 的方式来管理用户提交的任务。

• 对于串行队列来说，GCD每次从串行队列的队首取一个任务交给唯一的一个线程来处理，直到前一个任务完成后，才继续从队列中取下一个任务来执行，因此，串行队列中的任务执行严格按照提交顺序，并且后一个任务必须等前一个任务执行完成后才可以执行。

• 对于并发队列来说，GCD每次从并发队列的队首取一个任务，并将这个任务按照任务调度分发给多个线程中的某一个线程，此时不需要等待其完成，如果队列中还有其他任务，继续从队列中取出并分发给某一个线程来执行，由于底层由线程池管理多个线程，每个任务的时间复杂度不同再加上线程调度的影响，后提交的任务可能先执行完成。但对于单个线程执行并发队列来说，只能按队列里的任务顺序顺序执行，比如某个线程被安排了多个任务，那这个线程就只能按提交顺序依次执行任务。

所以，我们在使用GCD时也就很简单了，只需要创建或获取系统队列、编写任务并提交任务到队列即可。

注意点：

1. 线程和队列的关系：线程是来执行队列里的任务的。一个线程可以执行多个队列，也就是说，一个线程可以在多个队列里来回切换着执行，执行完这个队列里的一个任务，再执行另一个队列里的任务。

2. 主队列：主队列是一个串行队列，只有主线程能够执行主队列里的任务。平常的程序，都是放进主队列里来执行的。

3. 串行队列每次是由一个线程来执行一个任务的。 但是注意，只是一个线程而已，不代表这个线程一直会是同一个。如果这个一个线程执行完一个任务后被销毁了，会由另一个线程继续执行这个串行队列。

4. The global concurrent queues invoke blocks in FIFO order but do not wait for their completion, allowing multiple blocks to be invoked concurrently. 全局并发队列以FIFO顺序调用块，但不等待它们完成，允许同时调用多个块。

5. 并发队列的任务分发的时候，如果有多个线程，可以分给多个线程。但是，也可以将多个任务同时分给一个线程。这个看GCD拾遗2。

GCD创建队列或获取队列的方法

1. 获取主队列，即与主线程相关联的队列，它为串行队列：

/*
获取主队列，即与主线程相关联的队列
如果需要提交任务到主线程使用该方法获取主线程的主队列即可
主队列是串行队列因为只维护主线程一个线程
*/
dispatch_queue_t dispatch_get_main_queue(void);

/*
获取一个全局的并发队列
identifier指定该队列的优先级可选值有:
    DISPATCH_QUEUE_PRIORITY_HIGH 2
    DISPATCH_QUEUE_PRIORITY_DEFAULT 0
    DISPATCH_QUEUE_PRIORITY_LOW (-2)
    DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
flags：苹果关于第二个参数flags是这样写的：Flags that are reserved for future use. Always specify 0 for this parameter.保留供将来使用的标志。始终为此参数指定0。也就是说，flags一定要写0。有点疑惑这里？？
*/
dispatch_queue_t dispatch_get_global_queue(long identifier, unsigned long flags);

/*
创建一个队列
label 队列的名称
attr 队列的属性可选值有:
    DISPATCH_QUEUE_SERIAL 创建一个串行队列
    DISPATCH_QUEUE_CONCURRENT 创建一个并发队列
通过这种方式可以自己维护一个队列
*/
dispatch_queue_t dispatch_queue_create(const char *_Nullable label, dispatch_queue_attr_t _Nullable attr);

//获取串行主队列
dispatch_queue_t mainQueue = dispatch_get_mian_queue();

//获取一个默认优先级的并发队列
dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT);

//自定义创建一个名称为myConcurrentQueue的并发队列
dispatch_queue_t myConcurrentQueue = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT);

void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

void dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

/*
以异步方式执行任务，不阻塞当前线程
queue 管理任务的队列，任务最终交由该队列来执行
block block形式的任务，该block返回值、形参都为void
*/
void dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

/*
同上
context 是一个void*的指针，是work的第一个形参
work 是一个函数指针，指向返回值为void、形参为void*的函数，且形参不能为NULL，也就是说context一定要传，
使用起来不方便，一般不怎么用，需要使用C函数，也可以使用OC方法通过传递IMP来执行但是会有编译警告
*/
void dispatch_async_f(dispatch_queue_t queue, void *_Nullable context, dispatch_function_t work);

/*
以同步方式执行任务，阻塞当前线程，必须等待任务完成当前线程才可继续执行
*/
void dispatch_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);

//同上
void dispatch_sync_f(dispatch_queue_t queue, void *_Nullable context, dispatch_function_t work);

/*
以异步方式提交任务，在when时间点提交任务
queue 管理任务的队列，任务最终交由该队列来执行
block block形式的任务，该block返回值、形参都为void
*/
void dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);

//同上
void dispatch_after_f(dispatch_time_t when, dispatch_queue_t queue, void *_Nullable context, dispatch_function_t work);

/*
以异步方式提交任务，会阻塞queue队列，但不阻塞当前线程
queue 管理任务的队列，任务最终交由该队列来执行
需要说明的是，即时使用并发队列，该队列也会被阻塞，前一个任务执行完成才能执行下一个任务
block block形式的任务，该block返回值、形参都为void
*/
void dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

//同上
void dispatch_barrier_async_f(dispatch_queue_t queue, void *_Nullable context, dispatch_function_t work);

/*
以同步方式提交任务，会阻塞queue队列，也会阻塞当前线程
queue 管理任务的队列，任务最终交由该队列来执行
同样的，即时是并发队列该队列也会被阻塞，需要等待前一个任务完成，同时线程也会阻塞
block block形式的任务，该block返回值、形参都为void
*/
void dispatch_barrier_sync(dispatch_queue_t queue, DISPATCH_NOESCAPE dispatch_block_t block);

/同上
void dispatch_barrier_sync_f(dispatch_queue_t queue, void *_Nullable context, dispatch_function_t work);

/*
底层线程池控制block任务在整个应用的生命周期内只执行一次
predicate 实际为long类型，用于判断是否执行过
block block形式的任务，该block返回值、形参都为void
该方法常用于实现单例类，以及结合RunLoop创建一个常驻内存的线程
*/
void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);

- (void)viewWillAppear:(BOOL)animated
{
    //手动创建了一个并发队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    //也可以获取全局的并发队列，效果一样
    //dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    //异步提交一个任务到并发队列
    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    });
    //异步提交一个任务到并发队列
    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task2 %@ %d", [NSThread currentThread], i);
        }
    });
    //异步提交一个任务到并发队列
    dispatch_async(concurrentQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task3 %@ %d", [NSThread currentThread], i);
        }
    });

    //使用传递函数指针的方式有点复杂，以后的栗子不再赘述
    int context = 0;
    dispatch_async_f(concurrentQueue, &context, cFuncTask);
    //也可以使用OC方法，传入IMP，但会有警告
    //dispatch_async_f(concurrentQueue, &context, [self methodForSelector:@selector(ocFuncTask:)]);
}

//该函数是C函数
void cFuncTask(void* context)
{
    for (int i = 0; i < 500; i++)
    {
        NSLog(@"Task4 %@ %d", [NSThread currentThread], i);
    }
}
//OC方法
- (void)ocFuncTask:(void*) context
{
    for (int i = 0; i < 500; i++)
    {
        NSLog(@"Task4 %@ %d", [NSThread currentThread], i);
    }
}

Task4 <NSThread: 0x1c04776c0>{number = 7, name = (null)} 88
Task3 <NSThread: 0x1c04770c0>{number = 6, name = (null)} 63
Task1 <NSThread: 0x1c0474980>{number = 4, name = (null)} 99
Task2 <NSThread: 0x1c427c5c0>{number = 5, name = (null)} 0

- (void)viewWillAppear:(BOOL)animated
{
    //创建一个串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("mySerialQueue", DISPATCH_QUEUE_SERIAL);

    //异步提交一个任务到串行队列
    dispatch_async(serialQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    });
    //异步提交一个任务到串行队列
    dispatch_async(serialQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task2 %@ %d", [NSThread currentThread], i);
        }
    });
    //异步提交一个任务到串行队列
    dispatch_async(serialQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task3 %@ %d", [NSThread currentThread], i);
        }
    });
}

Task1 <NSThread: 0x1c0462280>{number = 4, name = (null)} 0
Task2 <NSThread: 0x1c0462280>{number = 4, name = (null)} 0
Task3 <NSThread: 0x1c0462280>{number = 4, name = (null)} 0

- (void)viewWillAppear:(BOOL)animated
{
    /*
    创建一个串行队列
    这里不可以使用主队列，因为执行该方法的是主线程，如果使用同步执行提交到主队列会造成死锁，后文会有具体讲解
    */
    dispatch_queue_t serialQueue = dispatch_queue_create("mySerialQueue", DISPATCH_QUEUE_SERIAL);

    //同步提交一个任务到串行队列
    dispatch_sync(serialQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    });

    //同步提交一个任务到串行队列
    dispatch_sync(serialQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task2 %@ %d", [NSThread currentThread], i);
        }
    });

    //同步提交一个任务到串行队列
    dispatch_sync(serialQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task3 %@ %d", [NSThread currentThread], i);
        }
    });
}

Task1 <NSThread: 0x1c0072c80>{number = 1, name = main} 0
Task2 <NSThread: 0x1c0072c80>{number = 1, name = main} 0
Task3 <NSThread: 0x1c0072c80>{number = 1, name = main} 0

- (void)viewWillAppear:(BOOL)animated
{
    //手动创建了一个并发队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("myConcurrentQueue", DISPATCH_QUEUE_CONCURRENT);
    //也可以获取全局的并发队列，效果一样
    //dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    //同步提交一个任务到并发队列
    dispatch_sync(concurrentQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    });

    //同步提交一个任务到并发队列
    dispatch_sync(concurrentQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task2 %@ %d", [NSThread currentThread], i);
        }
    });

    //同步提交一个任务到并发队列
    dispatch_sync(concurrentQueue, ^{
        for (int i = 0; i < 500; i++)
        {
            NSLog(@"Task3 %@ %d", [NSThread currentThread], i);
        }
    });
}

Task1 <NSThread: 0x1c0263200>{number = 1, name = main} 0
Task2 <NSThread: 0x1c0263200>{number = 1, name = main} 0
Task3 <NSThread: 0x1c0263200>{number = 1, name = main} 0

- (void)viewDidLoad {
    [super viewDidLoad];
    
    //主队列是串行队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();

    //异步提交一个任务到主队列
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 50; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    });
    //异步提交一个任务到主队列
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 50; i++)
        {
            NSLog(@"Task2 %@ %d", [NSThread currentThread], i);
        }
    });
    //异步提交一个任务到主队列
    dispatch_async(mainQueue, ^{
        for (int i = 0; i < 50; i++)
        {
            NSLog(@"Task3 %@ %d", [NSThread currentThread], i);
        }
    });
    
    //打印一行xxxxxxxxxx
    NSLog(@"xxxxxxxxxxxxxxx");
}

2018-08-17 11:00:07.697525+0800 GCD[859:68323] xxxxxxxxxxxxxxx
2018-08-17 11:00:07.702203+0800 GCD[859:68323] Task1 <NSThread: 0x60000006d3c0>{number = 1, name = main} 0
2018-08-17 11:00:07.702550+0800 GCD[859:68323] Task1 <NSThread: 0x60000006d3c0>{number = 1, name = main} 1
2018-08-17 11:00:07.703024+0800 GCD[859:68323] Task1 <NSThread: 0x60000006d3c0>{number = 1, name = main} 2
.....后面按照Task1-3的顺序输出

- (void)viewDidLoad {
    [super viewDidLoad];

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

    NSLog(@"开始");
    
    //异步提交一个任务到串行队列
    dispatch_sync(mainQueue, ^{
        for (int i = 0; i < 50; i++)
        {
            NSLog(@"Task1 %@ %d", [NSThread currentThread], i);
        }
    });
    
    NSLog(@"结束");
}

2018-08-17 11:21:04.826284+0800 GCD[882:81994] 开始

然后就崩溃了