iOS对GCD的一些操作

最新推荐文章于 2024-10-13 13:32:20 发布

转载最新推荐文章于 2024-10-13 13:32:20 发布 · 260 阅读

本文深入探讨GCD中的线程组(dispatch_group)和信号量(dispatch_semaphore)使用方法，通过具体示例讲解如何解决多接口数据请求后统一刷新界面及请求顺序执行的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

例子一

dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 处理耗时操作在此次添加

//通知主线程刷新
dispatch_async(dispatch_get_main_queue(), ^{
//在主线程刷新UI
});

});

例子二

iOS开发之线程组解决请求多个接口数据，完成后，再刷新界面

方法一

/线程组解决同一个界面需要请求多个接口数据，当全部请求完成后，再进入主线程刷新界面

这种问题使用 dispatch_group_enter(grpupE);来解决，dispatch_group_enter 和 dispatch_group_leave 必须要成对出现；

dispatch_group_enter ：使用一种手动的方式将另外一个 block 以不同于 dispatch_group_async 的方式添加到线程组中。在异步任务开始之前调用；

dispatch_group_leave ：手动指示一个 block 块执行完毕。以一种不用于 dispatch_group_async 的方式离开线程组，在异步任务执行完成之后调用；

如果不添加enter、leave，那么将会先执行完所有的外围方法操作，然后才会执行block中的内容，这样就无法实现数据全部完成后再刷新主界面的操作。其实这不难理解，比如block是在A方法中，block的执行，都是在A方法执行完后才会执行的

//1、不开启子线程的线程组简化方式
dispatch_group_t group = dispatch_group_create();
//模拟网络请求1
dispatch_group_enter(group);
//实际运用时，用网络请求的方法代替下面的内容，不要忘记leave 异步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 5; i++) {
[NSThread sleepForTimeInterval:1];
NSLog(@"当前线程：%@，是否是主线程：%@...1111···%d",[NSThread currentThread],[NSThread isMainThread]?@"是":@"否",i);//当前线程：<NSThread: 0x60000027ef40>{number = 3, name = (null)}，是否是主线程：否...1111···0
}
dispatch_group_leave(group);
});
NSLog(@"当前线程：%@，是否是主线程：%@...4444···",[NSThread currentThread],[NSThread isMainThread]?@"是":@"否");//当前线程：<NSThread: 0x604000071d40>{number = 1, name = main}，是否是主线程：是...4444···
//模拟网络请求2
dispatch_group_enter(group);
//实际运用时，用网络请求的方法代替下面的内容，不要忘记leave 异步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
for (int i = 0; i < 5; i++) {
[NSThread sleepForTimeInterval:1];
NSLog(@"当前线程：%@，是否是主线程：%@...2222···%d",[NSThread currentThread],[NSThread isMainThread]?@"是":@"否",i);//当前线程：<NSThread: 0x604000272540>{number = 4, name = (null)}，是否是主线程：否...2222···0
}
dispatch_group_leave(group);
});

dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"当前线程：%@，是否是主线程：%@...3333···",[NSThread currentThread],[NSThread isMainThread]?@"是":@"否");//当前线程：<NSThread: 0x604000071d40>{number = 1, name = main}，是否是主线程：是...3333···
});

方法二

一、简介

dispatch_group_enter：通知group，下面的任务马上要放到group中执行了。

dispatch_group_leave：通知group，任务完成了，该任务要从group中移除了。

这两种通知可以在多线程间自由穿梭的。

二、验证

下面用代码验证下它们的作用。

dispatch_group_t group =dispatch_group_create();

dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);

dispatch_group_enter(group);

//模拟多线程耗时操作

dispatch_group_async(group, globalQueue, ^{

sleep(3);

NSLog(@"%@---block1结束。。。",[NSThread currentThread]);

dispatch_group_leave(group);

});

NSLog(@"%@---1结束。。。",[NSThread currentThread]);

dispatch_group_enter(group);

//模拟多线程耗时操作

dispatch_group_async(group, globalQueue, ^{

sleep(3);

NSLog(@"%@---block2结束。。。",[NSThread currentThread]);

dispatch_group_leave(group);

});

NSLog(@"%@---2结束。。。",[NSThread currentThread]);

dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{

NSLog(@"%@---全部结束。。。",[NSThread currentThread]);

});

例子三

在实际开发中我们通常会遇到这样一种需求：某个页面加载时通过网络请求获得相应的数据，再做某些操作。有时候加载的内容需要通过好几个请求的数据组合而成，比如有两个请求A和B，我们通常为了省事，会将B请求放在A请求成功的回调中发起，在B的成功回调中将数据组合起来，这样做有明显的问题：

请求如果多了，需要写许多嵌套的请求

如果在除了最后一个请求前的某个请求失败了，就不会执行后面的请求，数据无法加载

请求变成同步的，这是最大的问题，在网络差的情况下，如果有n个请求，意味着用户要等待n倍于并发请求的时间才能看到内容

一、某界面存在多个请求，希望所有请求均结束才进行某操作。

同步请求这么low的方式当然是不可接受的，所以我们要并发这些请求，在所有请求都执行完成功回调后，再做加载内容或其他操作，考虑再三，选择用GCD的dispatch_group。

dispatch_group通常有两种用法，一种是

dispatch_group_async(<#dispatch_group_t group#>, <#dispatch_queue_t queue#>, <#^(void)block#>)

创建一个dispatch_group_t，将并发的操作放在block中，在

dispatch_group_notify(<#dispatch_group_t group#>, <#dispatch_queue_t queue#>, <#^(void)block#>)

的block中执行多组block执行完毕后的操作，对于网络请求来说，在请求发出时他就算执行完毕了，并不会等待回调，所以不满足我们的需求。

dispatch_group_t group = dispatch_group_create();
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求1
        NSLog(@"Request_1");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求2
        NSLog(@"Request_2");
    });
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求3
        NSLog(@"Request_3");
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //界面刷新
        NSLog(@"任务均完成，刷新界面");
    });

打印如下

Request_2
Request_1
Request_3
任务均完成，刷新界面

网络请求我们一般都用异步的，并不知道什么时候是否完成了。

所以采用另一种用法：

使用dispatch_group_enter(group)和dispatch_group_leave(group)，这种方式使用更为灵活，enter和leave必须配合使用，有几次enter就要有几次leave，否则group会一直存在。当所有enter的block都leave后，会执行dispatch_group_notify的block。

我们当然可以在网络请求前enter，在执行完每个请求的成功回调后leave，再在notify中执行内容加载，这样看来问题就解决了，就像这样：

dispatch_group_t group = dispatch_group_create();
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求1
        [网络请求:{
        成功：dispatch_group_leave(group);
        失败：dispatch_group_leave(group);
}];
    });
    dispatch_group_enter;
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求2
        [网络请求:{
        成功：dispatch_group_leave;
        失败：dispatch_group_leave;
}];
    });
    dispatch_group_enter(group);
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        //请求3
        [网络请求:{
        成功：dispatch_group_leave(group);
        失败：dispatch_group_leave(group);
}];
    });
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        //界面刷新
        NSLog(@"任务均完成，刷新界面");
    });
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

打印如下

Request_2
Request_1
Request_3
任务均完成，刷新界面

二、某界面存在多个请求，希望请求依次执行。

对于这个问题通常会通过线程依赖进行解决，因使用GCD设置线程依赖比较繁琐，这里通过NSOperationQueue进行实现，这里采用比较经典的例子，三个任务分别为下载图片，打水印和上传图片，三个任务需异步执行但需要顺序性。代码如下，下载图片、打水印、上传图片仍模拟为分别请求新闻列表3页数据。

    //1.任务一：下载图片
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        [self request_A];
    }];
 
    //2.任务二：打水印
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        [self request_B];
    }];
 
    //3.任务三：上传图片
    NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
        [self request_C];
    }];
 
    //4.设置依赖
    [operation2 addDependency:operation1];      //任务二依赖任务一
    [operation3 addDependency:operation2];      //任务三依赖任务二
 
    //5.创建队列并加入任务
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    [queue addOperations:@[operation3, operation2, operation1] waitUntilFinished:NO];

首先我们使用未添加信号量dispatch_semaphore时运行，打印如下

B___图片打水印
B___图片打水印
B___图片打水印
B___图片打水印
B___图片打水印
A___下载图片
A___下载图片
A___下载图片
A___下载图片
A___下载图片
C___上传打好水印的图片
C___上传打好水印的图片
C___上传打好水印的图片
C___上传打好水印的图片
C___上传打好水印的图片

根据打印结果可见，若不对请求方法做处理，其运行结果并不是我们想要的，联系实际需求，A、B、C请求分别对应下载图片、打水印、上传图片，而此时运行顺序则为B->A->C，在未获得图片时即执行打水印操作明显是错误的。重复运行亦会出现不同结果，即请求不做处理，其结果不可控无法预测。线程依赖设置并未起到作用。

解解决此问题的方法仍可通过信号量dispatch_semaphore进行解决。我们将请求方法替换为添加dispatch_semaphore限制的形式。
因此对于这种问题需要另辟蹊径，这里我们就要借助GCD中的信号量dispatch_semaphore进行实现，即营造线程同步情况。

dispatch_semaphore信号量为基于计数器的一种多线程同步机制。用于解决在多个线程访问共有资源时候，会因为多线程的特性而引发数据出错的问题。

如果semaphore计数大于等于1，计数-1，返回，程序继续运行。如果计数为0，则等待。

dispatch_semaphore_signal(semaphore)为计数+1操作。dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER)为设置等待时间，这里设置的等待时间是一直等待。我们可以通俗的理解为单柜台排队点餐，计数默认为0，每当有顾客点餐，计数+1，点餐结束-1归零继续等待下一位顾客。比较类似于NSLock。

dispatch_semaphore_t sema = dispatch_semaphore_create(0);
[网络请求:{
        成功：dispatch_semaphore_signal(sema);
        失败：dispatch_semaphore_signal(sema);
}];
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);

再次重复运行，我们会发现每次运行结果均一致，A、B、C三任务异步顺序执行（A->B->C）

A___下载图片
A___下载图片
A___下载图片
A___下载图片
A___下载图片
B___图片打水印
B___图片打水印
B___图片打水印
B___图片打水印
B___图片打水印
C___上传打好水印的图片
C___上传打好水印的图片
C___上传打好水印的图片
C___上传打好水印的图片
C___上传打好水印的图片

通过重复运行打印结果可证实确实实现了我们想要的效果。这样即解决了所提出的问题二。

后续
如果看的不是特别明白，可以看看这篇文章，写的很棒
点我进入

作者：so_what
链接：https://www.jianshu.com/p/657e994aeee2
来源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。