iOS 同步,异步,串行队列,并发队列,全局队列,主队列以及死锁

作者: 不走寻常way | 来源:发表于2019-10-25 10:09 被阅读0次

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

任务(Task): 你需要执行的操作
队列(Queue): 存放任务的容器

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

dispatch_async(dispatch_queue_t  _Nonnull queue, ^(void)block)
dispatch_sync(dispatch_queue_t  _Nonnull queue, ^(void)block)

这两个函数中均需要填入两个参数, 一个是队列, 一个是任务, 任务就是封装在block代码块中的. 所以, 我们在使用以上两个函数时, 只需要创建队列,将任务（block）添加进指定的队列中。并根据是否为sync决定调用该函数的线程是否需要阻塞。

注意:

这里调用该函数的线程并不执行参数中指定的任务（block块），任务的执行者是GCD分配给任务所在队列的线程。调用dispatch_sync和dispatch_async的线程，并不一定是任务（block块）的执行者。

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

同步执行：比如这里的dispatch_sync，这个函数会把一个block加入到指定的队列中，而且会一直等到执行完blcok，这个函数才返回。因此在block执行完之前，调用dispatch_sync方法的线程是阻塞的。

异步执行：一般使用dispatch_async，这个函数也会把一个block加入到指定的队列中，但是和同步执行不同的是，这个函数把block加入队列后不等block的执行就立刻返回了。

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

同步执行没有开启新线程的能力, 所有的任务都只能在当前线程执行
异步执行有开启新线程的能力, 但是, 有开启新线程的能力, 也不一定会利用这种能力, 也就是说, 异步执行是否开启新线程, 需要具体问题具体分析

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

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

串行队列可以保证在执行某个任务时，在它前面进入队列的所有任务肯定执行完了。对于每一个不同的串行队列，系统会为这个队列建立唯一的线程来执行代码。
但是并发队列它们的执行结束时间是不确定的，取决于每个任务的耗时。并发队列中的任务：GCD会动态分配多条线程来执行。具体几条线程取决于当前内存使用状况，线程池中线程数等因素。

清楚了以上概念,下面我们来根据他们的互相组合会发生什么,让我们拭目以待

1.同步执行+ 串行队列

- (void)syncSerial{
    /* 1.创建一个串行队列 */
    dispatch_queue_t serialQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_SERIAL);
    /* 2.将任务放在队列中 */
    dispatch_sync(serialQueue, ^{
        NSLog(@"download1--------%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"download2--------%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"download3--------%@",[NSThread currentThread]);
    });
}

执行情况:

download1--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download2--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download3--------<NSThread: 0x600003536cc0>{number = 1, name = main}

可以看出的是: 同步执行 + 串行队列没有开启新的线程, 所有的操作, 都是在当前线程执行.如果是在子线程中执行同步串行队列的操作, 当前的线程就是子线程,如下.

download1--------<NSThread: 0x600002e35b80>{number = 3, name = (null)}
执行完任务一
download2--------<NSThread: 0x600002e35b80>{number = 3, name = (null)}
执行完任务二
download3--------<NSThread: 0x600002e35b80>{number = 3, name = (null)}
执行完任务三

2.同步执行+ 并发队列

- (void)syncConcurrent{
    /* 1.创建一个并发队列 */
    dispatch_queue_t cuncurrentQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_CONCURRENT);
    /* 2.将不同的任务添加到队列中 */
    dispatch_sync(cuncurrentQueue, ^{
         NSLog(@"download1--------%@",[NSThread currentThread]);
    });
     NSLog(@"执行完任务一");
    dispatch_sync(cuncurrentQueue, ^{
        NSLog(@"download2--------%@",[NSThread currentThread]);
    });
     NSLog(@"执行完任务二");
    dispatch_sync(cuncurrentQueue, ^{
        NSLog(@"download3--------%@",[NSThread currentThread]);
    });
     NSLog(@"执行完任务三");
}

执行情况:

download1--------<NSThread: 0x600000530640>{number = 1, name = main}
执行完任务一
download2--------<NSThread: 0x600000530640>{number = 1, name = main}
执行完任务二
download3--------<NSThread: 0x600000530640>{number = 1, name = main}
执行完任务三

可以看出的是:三个任务都在主线程中执行, 并没有开启新的线程. 但是, 是不是所有的同步执行的操作都在主线程中执行呢? 当然不是. 看下面的代码

- (void)syncConcurrentOnBackgroundThread {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self syncConcurrent];
    });
}

同理:我把同步执行+ 并发队列这个操作也放到子线程去执行, 那么执行的线程就是子线程

download1--------<NSThread: 0x600002e38d00>{number = 4, name = (null)}
执行完任务一
download2--------<NSThread: 0x600002e38d00>{number = 4, name = (null)}
执行完任务二
download3--------<NSThread: 0x600002e38d00>{number = 4, name = (null)}
执行完任务三

3.异步执行+ 串行队列

- (void)asyncSerial{
    /* 1.创建一个串行队列 */
   dispatch_queue_t serialQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_SERIAL);
    /* 2.将不同的任务添加到队列中 */
    dispatch_async(serialQueue, ^{
        NSLog(@"download1--------%@",[NSThread currentThread]);
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"download2--------%@",[NSThread currentThread]);
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"download3--------%@",[NSThread currentThread]);
    });
}

执行情况:

download1--------<NSThread: 0x60000202cb00>{number = 3, name = (null)}
download2--------<NSThread: 0x60000202cb00>{number = 3, name = (null)}
download3--------<NSThread: 0x60000202cb00>{number = 3, name = (null)}

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

4.异步执行+ 并发队列

- (void)asyncConcurrent{
    /* 1.创建一个并发队列 */
  dispatch_queue_t concurrentQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_CONCURRENT);
    /* 2.将任务放到队列中, 下面的代码将三个任务放到队列中 */
    dispatch_async(concurrentQueue, ^{
        NSLog(@"download1-------%@",[NSThread currentThread]);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"download2-------%@",[NSThread currentThread]);
    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"download3-------%@",[NSThread currentThread]);
    });
}

执行情况:

执行完任务一
download3-------<NSThread: 0x600003d420c0>{number = 5, name = (null)}
download2-------<NSThread: 0x600003d42000>{number = 4, name = (null)}
download1-------<NSThread: 0x600003d5b840>{number = 3, name = (null)}

可以看出的是:开启了不同的线程, 且 $\color{red}{任务完成的顺序也是随机的}$ ,但是线程也不会无限开启,比如说你有100个任务,会开启100条线程吗? $\color{red}{答案是果断不会}$

除了以上这几类组合,还有两个概念,一个是全局并发队列和主队列

全局并发队列:就是我们常说的全局队列,它是一个并发队列, 它是系统为我们创建好的一个全局并发队列, 所以, 有时候, 我们不需要自己创建一个并发队列, 直接用系统为我们提供的全局队列就可以了,所以全局队列和同步执行以及异步执行的组合同并发队列是一样的
比较特殊的是主队列
主队列:系统会把主队列中的任务放在主线程中执行

5.异步执行+ 主队列

- (void)asyncMainQueue{
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"download1------%@",[NSThread currentThread]);
    });
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"download2------%@",[NSThread currentThread]);
    });
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"download3------%@",[NSThread currentThread]);
    });
}

执行情况:

download1------<NSThread: 0x600001906780>{number = 1, name = main}
download2------<NSThread: 0x600001906780>{number = 1, name = main}
download3------<NSThread: 0x600001906780>{number = 1, name = main}

需要注意的是:异步执行虽然有开启新线程的能力, 但是 $\color{red}{异步执行 + 主队列并不会开启新的线程,任务都是在主线程中执行的}$

6.同步执行+ 主队列

- (void)syncMainQueue{
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"download1------%@",[NSThread currentThread]);
    });
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"download2------%@",[NSThread currentThread]);
    });
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"download3------%@",[NSThread currentThread]);
    });
}

执行情况如下图:

死锁.png
直接奔溃,

关于死锁

1.概念

所谓死锁，通常指有两个线程T1和T2都卡住了，并等待对方完成某些操作。T1不能完成是因为它在等待T2完成。但T2也不能完成，因为它在等待T1完成。于是大家都完不成，就导致了死锁（DeadLock）

2.产生死锁的四个必要条件：

（1）互斥条件：一个资源每次只能被一个进程使用。
（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。
（3）不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。
（4）循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

首先来看一份经典的死锁代码:

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        dispatch_sync(dispatch_get_main_queue(), ^(void){
            NSLog(@"这里死锁了");
        });
    }
    return 0;
}

首先明确的是：执行这个dispatch_get_main_queue队列的是主线程。执行了dispatch_sync函数后，将block添加到了main_queue中，同时调用dispatch_sync这个函数的线程（也就是主线程）被阻塞，等待block执行完成，而执行主线程队列任务的线程正是主线程，此时他处于阻塞状态，所以block永远不会被执行，因此主线程一直处于阻塞状态。因此这段代码运行后，并非卡在block中无法返回，而是根本无法执行到这个block。

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

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

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

- (void)syncMainOnBackgroundThread{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self syncMainQueue];
    });
}

执行情况:

download1------<NSThread: 0x600001c0df40>{number = 1, name = main}
download2------<NSThread: 0x600001c0df40>{number = 1, name = main}
download3------<NSThread: 0x600001c0df40>{number = 1, name = main}

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

- (void)syncSerial{
    /* 1.创建一个串行队列 */
    dispatch_queue_t serialQueue = dispatch_queue_create("download.zavier.com", DISPATCH_QUEUE_SERIAL);
    /* 2.将任务放在队列中 */
    dispatch_sync(serialQueue, ^{
        NSLog(@"download1--------%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"download2--------%@",[NSThread currentThread]);
    });
    dispatch_sync(serialQueue, ^{
        NSLog(@"download3--------%@",[NSThread currentThread]);
    });
}

执行结果:

download1--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download2--------<NSThread: 0x600003536cc0>{number = 1, name = main}
download3--------<NSThread: 0x600003536cc0>{number = 1, name = main}

原因是:download.zavier.com这个队列的执行线程是主线程,同步执行不会开辟新线程,但这时候我们将任务添加到了download.zavier.com这个队列中,所以主线程会来立即执行这个队列中的任务，执行完成后就会返回，主线程不会继续被阻塞。所以不会死锁

2868984-3d697efcf03fcc3c.png

事实上,导致死锁的原因一定是:
在某一个串行队列中，同步的向这个串行队列添加block。

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

各种队列的执行效果图:

各种队形的执行效果图.png

参考文献:
iOS中GCD产生死锁原因分析及解决方案
 同步,异步,串行队列,并发队列,全局队列,主队列等概念的总结

iOS 同步,异步,串行队列,并发队列,全局队列,主队列以及死锁

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

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

注意:

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

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

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

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

清楚了以上概念,下面我们来根据他们的互相组合会发生什么,让我们拭目以待

1.同步执行+ 串行队列

2.同步执行+ 并发队列

3.异步执行+ 串行队列

4.异步执行+ 并发队列

除了以上这几类组合,还有两个概念,一个是全局并发队列和主队列

5.异步执行+ 主队列

6.同步执行+ 主队列

关于死锁

1.概念

2.产生死锁的四个必要条件：

这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。

各种队列的执行效果图:

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

iOS 功能类