同步,异步,串行队列,并发队列,全局队列,主队列等概念的总结

原文链接：https://www.jianshu.com/p/0aeb2848780d

在此之前, GCD中还涉及到两个十分重要的概念, 就是任务和队列

任务(Task): 你需要执行的操作

队列(Queue): 存放任务的容器

GCD中两个重要的函数, 一个同步执行, 一个异步执行

异步、同步

这个函数中需要填入两个参数, 一个是队列, 一个是任务, 任务就是封装在block代码块中的. 所以, 我们在使用以上两个函数时, 只需要创建队列, 以及把自己需要执行的代码封装在block中就可以了

那么, 同步执行和异步执行有什么区别呢?

假如我有A,B,C三个任务

如果这三个任务都是同步执行, 程序将等待A 执行完毕之后, 再执行B, 再执行C

如果这三个任务都是是异步执行, 程序直接跳过A,B,C,执行后面的代码, 执行完毕之后, 再来执行A,B,C中的任务

另外, 还有一点需要明确的是：

同步执行没有开启新线程的能力, 所有的任务都只能在当前线程执行

异步执行有开启新线程的能力, 但是, 有开启新线程的能力, 也不一定会利用这种能力, 也就是说, 异步执行是否开启新线程, 需要具体问题具体分析。

我们再来看一下串行队列和并发队列

无论任何队列, 其实都遵循FIFO(first in first out, 先进先出原则),

但是:

并发队列中的任务会放到不同的线程中去执行.

串行队列中的任务只会放到同一线程中去执行.

如下图所示

串行队列

并行队列

那么同步执行,异步执行,并发队列,串行队列互相组合又会发生什么样的情况呢? 这个时候, 就有四种情况需要分析了

情况1 : 异步执行 + 并发队列：

    /////////异步执行 + 并发队列///////////
    dispatch_queue_t concurrentQueue = dispatch_queue_create("线程测试.com", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(concurrentQueue, ^{
        NSLog(@"当前线程11---------%@",[NSThread currentThread]);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"当前线程22---------%@",[NSThread currentThread]);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"当前线程33---------%@",[NSThread currentThread]);
    });

异步执行 + 并发队列执行情况

可以看出, 开启了不同的线程, 任务完成的顺序也是随机的

但是不同的任务都开启一个独立的线程, 那我有100个任务,会开启100条线程吗? 答案是果断不会, 如下图所示

线程开启数量不会无限增加

可以看出的是, 任务,10,11,12利用了之前的线程, 所以线程是不会无限开启的.

情况2 : 异步执行 + 串行队列：

/////////异步执行 + 串行队列///////////
    //创建一个串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("线程测试.com", DISPATCH_QUEUE_SERIAL);
    //将不同的任务添加到队列中
    dispatch_async(serialQueue, ^{
        NSLog(@"当前线程1---------%@",[NSThread currentThread]);
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"当前线程2---------%@",[NSThread currentThread]);
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"当前线程3---------%@",[NSThread currentThread]);
    });

异步执行 + 串行队列执行情况

可以看出的是: 异步执行 + 串行队列也开启了新的线程, 但是不管任务有多少个, 异步执行 + 同一条串行队列只开启一条新的线程, 任务的执行顺序也是按照队列中的顺序执行的,因为同一条线程中, 必须等到前一个任务执行完毕后, 才能执行下一个任务.

情况3 : 同步执行+ 并发队列：

/////////情况3 : 同步执行+ 并发队列///////////
    //创建一个并发队列
    dispatch_queue_t serialQueue = dispatch_queue_create("线程测试.com", DISPATCH_QUEUE_SERIAL);
    //将不同的任务添加到队列中
    dispatch_sync(serialQueue, ^{
        NSLog(@"当前线程1---------%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"当前线程2---------%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"当前线程3---------%@",[NSThread currentThread]);
    });

情况3 : 同步执行+ 并发队列执行情况

三个任务都在主线程中执行, 并没有开启新的线程. 但是, 是不是所有的同步执行的操作都在主线程中执行呢? 当然不是. 看下面的代码，将其执行放到子线程：

dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self test3];
});

同步执行+ 并发队列在子线程中执行

所以说, 同步执行+ 并发队列, 并不会开启新的线程, 即使是并发队列, 也然并卵；

情况4 : 同步执行+ 串行队列：

/////////情况4 : 同步执行+ 串行队列///////////
    //创建一个串行队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("线程测试.com", DISPATCH_QUEUE_CONCURRENT);
    //将不同的任务添加到队列中
    dispatch_sync(concurrentQueue, ^{
        NSLog(@"当前线程1---------%@",[NSThread currentThread]);
    });
    dispatch_sync(concurrentQueue, ^{
        NSLog(@"当前线程2---------%@",[NSThread currentThread]);
    });
    dispatch_sync(concurrentQueue, ^{
        NSLog(@"当前线程3---------%@",[NSThread currentThread]);
    });

情况4 : 同步执行+ 串行队列

如果是在子线程中执行同步串行队列的操作, 当前的线程就是子线程

同步执行 + 串行队列子线程执行情况

总之, 需要记住的就是, 同步执行并没有开启子线程的能力, 所有的操作, 都是在当前线程执行.

故事到这里就结束了吗? 并没有

还有一个全局并发队列和主队列, 这两个又是什么鬼呢?

全局并发队列就是我们常说的全局队列

首先, 它是一个并发队列, 他是系统为我们创建好的一个全局的并发队列, 所以, 有时候, 我们不需要自己创建一个并发队列, 直接用系统为我们提供的全局队列就可以了,所以全局队列和同步执行以及异步执行的组合同并发队列是一样的

比较特殊的是主队列

系统会把主队列中的任务放在主线程中执行

情况5 : 异步执行+ 主队列：

/////////情况5 : 异步执行+ 主队列///////////
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_async(queue, ^{
        NSLog(@"当前线程1---------%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"当前线程2---------%@",[NSThread currentThread]);
    });
    dispatch_async(queue, ^{
        NSLog(@"当前线程3---------%@",[NSThread currentThread]);
    });

情况5 : 异步执行+ 主队列

异步执行虽然有开启新线程的能力, 但是异步执行 + 主队列并不会开启新的线程, 任务都是在主线程中执行的。

情况6 : 同步执行+ 主队列：

/////////情况6 : 同步执行+ 主队列///////////
    dispatch_queue_t queue = dispatch_get_main_queue();
    dispatch_sync(queue, ^{
        NSLog(@"当前线程1---------%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"当前线程2---------%@",[NSThread currentThread]);
    });
    dispatch_sync(queue, ^{
        NSLog(@"当前线程3---------%@",[NSThread currentThread]);
    });

情况6 : 同步执行+ 主队列执行情况

直接崩溃了, 以前这种情况是会发生死锁的, 那么, 为什么会发生这种情况呢?

可以这样理解, 上图中, 执行syncMainQueue这个方法是在主线程中执行的, 你可以把它看做一个任务A, 这个任务A也是在主队列中的,那么代码执行到下一步的时候, 启动了任务B, 把任务B放进了主队列中, 由于是同步执行, 所以, 必须等待任务B执行完了之后才能继续向下执行, 但是主线程有任务A, 所以任务B无法放到主线程中去执行,任务B等待任务A执行, 任务A等待任务B执行, 这样就造成了死锁。

同步执行+ 主队列造成死锁的原因

但是, 如果将同步执行+ 主队列的操作放到子线程中执行, 就不会造成死锁

dispatch_async(dispatch_get_global_queue(0, 0), ^{
[self test3];
});

同步执行+ 主队列在子线程中执行情况

那为什么同步执行 + 串行队列不会造成死锁呢?

同步执行是不会开启新的线程的, 如果当前线程是主线程, 则任务在主线程中执行. 如下图所示

同步执行+ 串行队列不会造成死锁

说了这么多, 可能又有点晕, 其实这些应该在实际开发中慢慢体会, 碰到的情况多了, 自然而然就明白了. 现在, 我们只要记住下面的表格就可以了

各种队列的执行效果图:

各种队列的执行效果图

多运用自然能熟记于心。