美文网首页多线程网络技术栈多线程
多个网络请求ABC执行完再执行D的正确理解(GCD线程同步)

多个网络请求ABC执行完再执行D的正确理解(GCD线程同步)

作者: 半岛夏天 | 来源:发表于2018-09-27 14:10 被阅读125次

    前言

    我发现网络上很多介绍多线程的案例感觉都是错误的例子。也不能说错的,例如用异步并发队列的时候,他们只是打印了一个log,这种打印的行为本身就是同步任务,肯定按照最简单的例子进行打印了,看到的效果自然是很多文章所说的。但是如果你Block里面的任务是网络请求呢?还能保证网络异步任务的一致性?很显然大部分文章压根没有考虑任务的异步性,而且显示开发中大部分任务都是异步的,因此本文先从网上的同步任务,也就是比较简单的案例开始介绍,最后再通过一道阿里的面试题来引出实际开发中的问题,这个题目非常有代表性。

    线程同步

    同步异步并发串行什么的可以看看这个简单的介绍

    阿里有个面试题

    使用GCD如何实现A,B,C三个任务并发,完成后执行任务D?

    // 异步 并发队列 当前线程不等待,而且任务是并发队列,一次可以执行多个
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            // 第一种 同步任务
            NSLog(@"同步任务打印1");
            // 第二种 网络请求发送任务 (发送这个操作是任务,而网络返回的报文是不归任务管理的,因此发送任务发送之后,任务已经结束)
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"异步任务返回报文打印1");
            });
        });
    

    可以看到异步并发任务有两种,一种任务是同步的,一种任务是网络请求,发送操作是同步的,但是请求到的结果是异步的。阿里的面试题,肯定是后者异步并发队列里面的任务也是并发的操作,如何实现ABC三个网络请求都回来之后->执行D这样的操作?

    异步并发(同步任务)

    同步任务很简单,也是所有你能搜到的资料告诉你如何做到的几个方法。

    第一种GCD group

        dispatch_group_t group = dispatch_group_create();
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务A");
        });
        
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务B");
        });
        
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务C");
        });
        
        dispatch_group_notify(group, queue, ^{
            NSLog(@"任务完成执行");
        });
    //    2018-04-18 10:18:52.950271+0800 GCD[2283:78081] 同步任务B
    //    2018-04-18 10:18:52.950271+0800 GCD[2283:78082] 同步任务C
    //    2018-04-18 10:18:52.950273+0800 GCD[2283:78083] 同步任务A
    //    2018-04-18 10:18:52.950424+0800 GCD[2283:78082] 任务完成执行
        
    //    2018-04-18 10:19:30.821003+0800 GCD[2315:79354] 同步任务B
    //    2018-04-18 10:19:30.821003+0800 GCD[2315:79355] 同步任务A
    //    2018-04-18 10:19:30.821003+0800 GCD[2315:79370] 同步任务C
    //    2018-04-18 10:19:30.821145+0800 GCD[2315:79355] 任务完成执行
    

    可以看到,异步线程,并发队列里面,三个任务可以同时执行,因此打印顺序随机。但是由于打印的任务,这个打印的动作是同步的,没有再开线程有其他进一步的异步操作,所以你看起来好像没什么问题。

    第二种 dispatch_barrier_async

    dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_CONCURRENT);
        dispatch_async(queue, ^{
            NSLog(@"任务A");
        });
        
        dispatch_async(queue, ^{
            NSLog(@"任务B");
        });
        
        dispatch_async(queue, ^{
            NSLog(@"任务C");
        });
        
        dispatch_barrier_async(queue, ^{
            NSLog(@"阻塞自定义并发队列");
        });
        
        dispatch_async(queue, ^{
            NSLog(@"任务D");
        });
        
        dispatch_async(queue, ^{
            NSLog(@"任务E");
        });
    

    注意,这里用到的dispatch_barrier_async如果使用的队列是dispatch_global_queue,那么就等同意dispatch_async,起不到阻塞的作用。我们需要自己创建并发队列,然后再执行barrier函数,前面ABC三个任务随机,后面DE随机,但是DE的执行必须是等待ABC任务执行完的。

    第三种 NSOperation

    NSBlockOperation *operatioon1 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"任务A");
        }];
        
        NSBlockOperation *operatioon2 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"任务B");
        }];
        
        NSBlockOperation *operatioon3 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"任务C");
        }];
        
        NSBlockOperation *operatioon4 = [NSBlockOperation blockOperationWithBlock:^{
            NSLog(@"任务D");
        }];
        
        [operatioon4 addDependency:operatioon1];
        [operatioon4 addDependency:operatioon2];
        [operatioon4 addDependency:operatioon3];
        
        NSOperationQueue *queue = [[NSOperationQueue alloc] init];
        [queue addOperations:@[operatioon1,operatioon2,operatioon3,operatioon4] waitUntilFinished:YES];
        NSLog(@"完成之后的操作");
    

    通过任务之间的依赖关系执行,最后的参数YES的时候是会阻塞当前线程,执行完之后再往后执行,NO的话就不阻塞

    可以看到,上面的都是异步并发操作,而里面的任务是同步的,这里的任务指的是Block里面的所有操作,但是如果Block里面的操作是网络请求,也是异步的,那上面的做法就会有问题了,看如下代码

    错误例子

        dispatch_group_t group = dispatch_group_create();
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务A");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务AA");
            });
        });
        
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务B");
        });
        
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务C");
        });
        
        dispatch_group_notify(group, queue, ^{
            NSLog(@"任务完成执行");
        });
    //    2018-04-18 10:53:16.294263+0800 GCD[3287:115681] 同步任务B
    //    2018-04-18 10:53:16.294263+0800 GCD[3287:115679] 同步任务C
    //    2018-04-18 10:53:16.294263+0800 GCD[3287:115699] 同步任务A
    //    2018-04-18 10:53:16.294430+0800 GCD[3287:115699] 任务完成执行
    //    2018-04-18 10:53:18.294592+0800 GCD[3287:115646] 网络异步任务AA
    

    用dispatch_after来模拟网络请求,可以看到,同步任务ABC->D这些操作还是正确的,但是里面有个模拟网络请求的任务,就不会按我们所想的顺序执行了。为什么呢?很简单,首先都是异步的,子线程操作,而且是并发队列,那么任务可以多个一起,如果任务是单纯的打印,即同步任务,那么就能完成我们的预期,如果Block任务里面还嵌套异步任务,因为并发队列里面的任务,只是负责打印和发送请求的操作,异步回调数据是不归队列管的,任务的执行完毕,只是Block代码块代码执行完,如果里面还包含异步任务,这里就需要通过信号量dispatch_semaphore来实现了。

    下面就来实现如果并发队列里面的任务是网络请求,如何等ABC三个网络请求回调之后,再执行D?

    先来介绍下Dispatch_semaphore的使用

    dispatch_semaphore是GCD用来同步的一种方式,与他相关的共有三个函数,分别是dispatch_semaphore_create,dispatch_semaphore_signal,dispatch_semaphore_wait,信号量1的时候一般都当做锁来看待。

    参考文章:关于dispatch_semaphore的使用

    异步并发(模拟网络异步任务)

    子线程同时执行ABC三个同步任务、全部执行完成再在子线程执行三个同步任务D。

    说队列组/依赖基本可以确定了解GCD/NSOpertion。但是比较麻烦、用线程栅栏dispatch_barrier的话会更简便一些

    这个就是上面的同步介绍面试题

    上一题中的ABC三个任务改成异步任务(如AFN网络请求)、全部回调成功后进行数据整合。
    如果只说队列/任务组肯定不行。因为网络请求本身是异步的、任务会立即完成、但数据还没有回来。
    最好的就是在队列组的前提下。把异步的网络请求转化为同步、以捕获正确的完成时机。
    具体操作需要使用信号量。

    这里有个帖子有介绍这个,但是没有具体Demo,下面看看如何组合信号量实现的

    第一种 dispatch_group + semaphore

        dispatch_group_t group = dispatch_group_create();
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务A");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务一");
                dispatch_semaphore_signal(semaphore);
            });
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        });
        
        dispatch_group_async(group, queue, ^{
            
            NSLog(@"同步任务B");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.8f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务二");
                dispatch_semaphore_signal(semaphore);
            });
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        });
        
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务C");
        });
        
        dispatch_group_async(group, queue, ^{
            
            NSLog(@"同步任务D");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.5f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务四");
                dispatch_semaphore_signal(semaphore);
            });
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        });
        
        dispatch_group_notify(group, queue, ^{
            NSLog(@"任务完成执行");
        });
    

    分析如下:

    异步并发队列,里面添加了四个任务,任务AB有网络请求,C同步任务打印,D也有网络请求,如何在ABCD四个任务完成,而且网络请求也完成之后执行之后的操作?

    可以看到,Block整个就是一个任务,如果没有dispatch_semaphore_wait,带有网络请求的任务,因为网络请求本身是异步的、任务会立即完成、但数据还没有回来。,因为发送网络请求,就已经把Block的任务完成了,异步回来的操作已经不属于并发队列里面的管理的任务了。就和上面的错误例子一样,完成任务的执行,和请求回调没有任何顺序关系了。那么如果我们在Block里面加了dispatch_semaphore_wait,什么意思呢?如果信号量为0的时候,那么就会一直在这里等待。可以理解为一开始发送网络请求出去,这个时候执行到wait函数,信号量为0,等待,队列任务没有执行完,只有当请求回来的时候调用singnal的时候,信号+1,wait的函数随机获取到信号,放开任务,执行完毕一个,剩下的没有获取到的信号继续等待,那么就会按我们的,执行完一个网络请求,信号+1,释放一个wait,执行完一个Block任务,那么,当所有的网络请求执行完,所有的wait都被释放,任务都完成了,才会通知Group调用完成。

    第二种 dispatch_group_enter 和 dispatch_group_leave

    dispatch_group_t group = dispatch_group_create();
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        dispatch_group_enter(group);
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务A");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务一");
                dispatch_group_leave(group);
            });
        });
        
        dispatch_group_enter(group);
        dispatch_group_async(group, queue, ^{
            
            NSLog(@"同步任务B");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.8f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务二");
                dispatch_group_leave(group);
            });
        });
        dispatch_group_enter(group);
        dispatch_group_async(group, queue, ^{
            NSLog(@"同步任务C");
            dispatch_group_leave(group);
        });
        
        dispatch_group_enter(group);
        dispatch_group_async(group, queue, ^{
            
            NSLog(@"同步任务D");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.5f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络异步任务四");
                dispatch_group_leave(group);
            });
        });
        
        dispatch_group_notify(group, queue, ^{
            NSLog(@"任务完成执行");
        });
    

    这种方法也是我之前项目中用的,也能实现上面的执行顺序。

    ABCD异步顺序随机,无论任务是否有异步,都会等任务执行完(包括网络请求)再执行任务完成

    异步串行(同步任务)

    这个没什么好说的,同步任务,在串行队列,肯定顺序执行

    异步串行(异步任务)

    但是如果串行队列里面的任务是网络请求如何,再让等网络请求回调之后也顺序执行?

    看代码 不做处理

    dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL);
        dispatch_async(queue, ^{
            NSLog(@"执行任务一");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络任务一");
            });
        });
        
        dispatch_async(queue, ^{
            NSLog(@"执行任务二");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.6 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络任务二");
            });
        });
        
        dispatch_async(queue, ^{
            NSLog(@"执行任务三");
        });
        
        dispatch_async(queue, ^{
            NSLog(@"执行完成");
        });
        2018-04-18 12:11:04.956900+0800 GCD[4889:182340] 执行任务一
        2018-04-18 12:11:04.957076+0800 GCD[4889:182340] 执行任务二
        2018-04-18 12:11:04.957183+0800 GCD[4889:182340] 执行任务三
        2018-04-18 12:11:04.957290+0800 GCD[4889:182340] 执行完成
        2018-04-18 12:11:05.557397+0800 GCD[4889:182291] 网络任务二
        2018-04-18 12:11:07.156658+0800 GCD[4889:182291] 网络任务一
    

    可以看到串行队列任务执行是顺序的,但是异步网络请求回调是不按顺序的。下面我们用dispatch_semaphore处理下

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
        dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL);
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"执行任务一");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0f * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络任务一");
                dispatch_semaphore_signal(semaphore);
            });
        });
        
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"执行任务二");
            dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(0.6 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
                NSLog(@"网络任务二");
                dispatch_semaphore_signal(semaphore);
            });
        });
        
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"执行任务三");
            dispatch_semaphore_signal(semaphore);
        });
        
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            NSLog(@"执行完成");
            dispatch_semaphore_signal(semaphore);
        });
        
        2018-04-18 13:54:20.412918+0800 GCD[6841:262952] 执行任务一
        2018-04-18 13:54:22.413131+0800 GCD[6841:262916] 网络任务一
        2018-04-18 13:54:22.413369+0800 GCD[6841:262952] 执行任务二
        2018-04-18 13:54:23.073214+0800 GCD[6841:262916] 网络任务二
        2018-04-18 13:54:23.073512+0800 GCD[6841:262952] 执行任务三
        2018-04-18 13:54:23.073697+0800 GCD[6841:262952] 执行完成
    

    当异步串行队列,而且任务有网络异步请求,我们需要用信号量,每次开放一个任务,当一个任务无论是同步还是异步,都是操作完之后再把信号量+1,然后下一个任务才会解锁。这里的信号量可以当做锁来理解。

    总结

    异步并发执行同步任务,可以用dispatch_group,dispatch_barrier和NSOperation的依赖

    异步串行执行同步任务,默认就是顺序执行

    异步并发执行异步任务,可以用dispatch_group+semaphore 初始化信号为0,执行完一个异步通过singnal释放一个wait任务

    或者用disaptch_group_enter 和 dispatch_group_leave

    异步串行执行异步任务,可以用dispatch_semaphore 初始化信号为1,顺序执行任务,每个任务都加锁,执行任务消耗锁,顺延任务等待,执行完一个任务,singnal,然后下一个任务开锁顺序执行

    如果多个任务网络请求,NSOperation我感觉无法实现 多网络任务执行完之后再最终统一执行某一个人任务。这个时候只有用dispatch_group + semaphore来实现

    延伸阅读:

    相关文章

      网友评论

        本文标题:多个网络请求ABC执行完再执行D的正确理解(GCD线程同步)

        本文链接:https://www.haomeiwen.com/subject/npjeoftx.html