GCD编程中任务的执行顺序

作者: 东了个尼 | 来源:发表于2017-11-30 08:50 被阅读0次

GCD编程中任务的执行顺序
2022-07-25
2019 iOS面试题-----多线程相关之GCD、死锁、dis
GCD学习
gcd中组队列group
《Objective-C 高级编程》GCD 笔记摘要
iOS多线程编程之GCD
iOS GCD扩展用法
iOS 中线程与队列的关系
GCD解析

本篇文章是对上篇文章开发多线程的一个补充。重点在于探究GCD编程中，任务的执行顺序，掌握好任务的执行顺序，我们才能很好的去使用GCD。串行队列、并行队列、同步、异步是gcd编程中四个非常重要的概念，它们的组合会产生多种不同的执行顺序。下面我们来举例探究一下。

1.串行队列异步任务

-(void)method_one{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_SERIAL);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"async--%@",[NSThread currentThread]);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);

}

执行结果如下：

串行队列异步任务

分析：在方法method_one中我们首先创建了一个串行的队列，然后使用for循环往串行队列中追加了10个异步任务。先在主线程中执行打印start—，然后将异步任务添加到串行队列中（只是添加，并没有立即执行），之后在主线程打印end—，最后才会从串行队列中依次取出一个任务，并在子线程中执行，由于串行队列执行任务是有序的，因此异步任务打印是有序的。所以，主线程会在执行完dispatch_async方法后，立即返回执行主线程后续相关操作，主线程任务执行完毕后，才会在子线程中依次执行异步任务。由于串行队列中的任务是依次取出来执行的，即前一个任务在子线程执行完毕后，才能取出后一个任务来执行，并且只创建了一个子线程。

1.2 创建多个串行队列，将异步任务添加进去
我们将上面的代码稍微改变一下

-(void)method_one{
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
／／创建多个串行队列
        dispatch_async( dispatch_queue_create("fdd", DISPATCH_QUEUE_SERIAL), ^{
            NSLog(@"async--%@",[NSThread currentThread]);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);
}

执行结果：

屏幕快照 2017-11-23 上午10.19.39.png

分析：在for循环中，我们同时创建多个串行队列，将异步任务分别添加到不同的队列中，这个时候会创建10个串行队列，开启10条子线程，去异步的执行这些任务，所以任务的执行顺序是无序的。

2.串行队列同步任务

-(void)method_2{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_SERIAL);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);
}

执行结果如下：

屏幕快照 2017-11-23 上午10.25.46.png

分析：创建了一个串行队列，然后往串行队列中添加了10个同步任务，从打印结果可以看出：先在主线程中执行打印start—，然后在主线程依次打印同步任务，最后在主线程打印end—。所以，主线程在执行dispatch_sync方法后，并没有立刻返回，而是阻塞了当前线程，去等待dispatch_sync方法里面的block执行完毕，等到for循环里面所有同步任务执行完毕后，才返回去执行后面的end—的打印操作，所有的打印都是在主线程完成。

3.并行队列异步任务

-(void)method_3{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"async--%@ i = %d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);
}

执行结果

屏幕快照 2017-11-23 上午10.30.52.png

分析：先在主线程中执行打印start—，然后将异步任务添加到并行队列中（只是添加，并没有立即执行），之后立刻返回，在主线程打印end—，最后才会从并行队列中依次取出多个任务，并创建多个子线程来执行（至于创建几个子线程由系统决定），由于每个任务执行时间不同，子线程获得CPU的时间也不同，所以异步任务打印结果的顺序也不同，而且每次打印的同步任务结果都不一样。

4.并行队列同步任务

-(void)method_4{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);
}

执行结果

并行队列同步任务

分析：先在主线程中执行打印start—，由于是同步任务，所以不会创建子线程，任务会全部在主线程执行，在主线程依次打印同步任务，最后在主线程打印end—。所以，主线程在执行dispatch_sync方法后，并没有立刻返回，而是阻塞了当前线程，去等待dispatch_sync方法里面的block执行完毕，等到for循环里面所有同步任务执行完毕后，才返回去执行后面的end—的打印操作，所有的打印都是在主线程完成。

5.全局队列同步任务

- (void)method_6{
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
  dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);  
}

执行结果：

屏幕快照 2017-11-23 上午10.45.07.png

分析：全局队列也是并发队列的一种，不用创建可以直接获取。先在主线程中执行打印start—，由于是同步任务，所以不会创建子线程，任务会全部在主线程执行，在主线程依次打印同步任务，最后在主线程打印end—。所以，主线程在执行dispatch_sync方法后，并没有立刻返回，而是阻塞了当前线程，去等待dispatch_sync方法里面的block执行完毕，等到for循环里面所有同步任务执行完毕后，才返回去执行后面的end—的打印操作，所有的打印都是在主线程完成。

5.全局队列异步任务


- (void)method_8{
    dispatch_queue_t q =dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end--%@",[NSThread currentThread]);
}

执行结果

屏幕快照 2017-11-23 上午11.24.41.png

分析：先在主线程中执行打印start—，由于是同步任务，所以不会创建子线程，任务会全部在主线程执行，在主线程依次打印同步任务，最后在主线程打印end—。所以，主线程在执行dispatch_sync方法后，并没有立刻返回，而是阻塞了当前线程，去等待dispatch_sync方法里面的block执行完毕，等到for循环里面所有同步任务执行完毕后，才返回去执行后面的end—的打印操作，所有的打印都是在主线程完成。

6.串行队列中先异步再同步

-(void)method_9{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_SERIAL);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"async--%@ i = %d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end1--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end2--%@",[NSThread currentThread]);
}

执行结果

屏幕快照 2017-11-23 下午1.29.24.png

分析：先在主线程中执行打印start—，然后将异步任务添加到串行队列中（只是添加，并没有立即执行），之后在主线程打印end1—，再然后往串行队列里添加了1个同步任务，此时主线程堵塞，等待串行队列里地同步任务执行完毕。此时创建一个子线程开始依次执行异步任务，异步任务结束后，在主线程中执行同步任务（上面的结论）。1个同步任务执行完后（此时串行队列里没有任务了），主线程返回，for循环继续往串行队列里添加1个同步任务，此时主线程继续阻塞，等待串行队列里同步任务执行完毕，此时主线程执行这个同步任务，执行完毕后，主线程返回继续for循环……。等for循环结束后，最后在主线程执行打印end2—的操作。

7.串行队列中先同步再异步

-(void)method_10{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_SERIAL);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end1--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"async--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end2--%@",[NSThread currentThread]);
}

执行结果

屏幕快照 2017-11-23 下午1.26.40.png

分析：先在主线程中执行打印start—，然后往串行队列里添加了1个同步任务，此时主线程堵塞，等待串行队列里地同步任务执行完毕。此时创建一个子线程开始依次执行串行队列的任务，在主线程中执行同步任务（上面的结论）。1个同步任务执行完后（此时串行队列里没有任务了），主线程返回，for循环继续往串行队列里添加1个同步任务，此时主线程继续阻塞，等待串行队列里同步任务执行完毕，此时主线程执行这个同步任务，执行完毕后，主线程返回继续for循环……。等for循环结束后，在主线程打印end1—，然后执行到dispatch_async往串行队列里添加异步任务，并立即返回，for循环结束后，串行队列里有10个异步任务，此时主线程继续往下执行打印end2—的操作。之后开始创建子线程依次执行串行队列里地异步任务。

8.并行队列中先异步再同步

-(void)test7{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"async--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end1--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end2--%@",[NSThread currentThread]);
}

执行结果

屏幕快照 2017-11-23 下午1.34.15.png

分析：上面代码创建了一个并行队列，然后往并行队列中添加了10个异步任务和10个同步任务，上面只是某一次的打印结果，每次的打印结果都不一样，从打印结果可以看出：由于是并行队列，会开启多个子线程执行异步任务，所以异步任务的打印结果是无序的，而同步任务由于都是在主线程中执行，所有总体是有序的。而且同步与异步任务是交叉着执行完毕的。

9.并行队列中先同步再异步

-(void)method_10{
    dispatch_queue_t q = dispatch_queue_create("FDD", DISPATCH_QUEUE_CONCURRENT);
    NSLog(@"start--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_sync(q, ^{
            NSLog(@"sync--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end1--%@",[NSThread currentThread]);
    for (int i=0; i<10; i++) {
        dispatch_async(q, ^{
            NSLog(@"async--%@---%d",[NSThread currentThread],i);
        });
    }
    NSLog(@"end2--%@",[NSThread currentThread]);
}

执行结果

屏幕快照 2017-11-23 下午1.37.36.png

分析：每次的打印结果也不一定一样，从打印结果可以看出：都是先有序的执行完同步任务，再无序的执行异步任务，原因在于先添加的同步任务，没添加一个同步任务会堵塞主线程，等待同步任务执行完毕，所以会依次在主线程执行同步任务，for循环结束后，此时并行队列里为空，之后再往并行队列中添加了10个异步任务，此时没有堵塞主线程，主线程一直往下执行打印end2—，此时开启多个子线程来执行执行异步任务，所以执行完的顺序是未知的。

总结： 1. GCD中的FIFO队列称为dispatch queue，它可以保证先进来的任务先得到执行（但不保证一定先执行结束）。
2.串行队列异步任务，会创建子线程，且只创建一个子线程，异步任务执行是有序的。
3.并行队列异步任务创建子线程，且多个子线程，异步任务打印结果无序。
4.同步、异步决定是否创建子线程，同步任务不创建子线程，都是在主线程中执行，异步任务创建子线程。
5.串行、并行决定创建子线程的个数，串行创建一个子线程，并行创建多个子线程（具体几个由系统决定）。