在实际开发中，应该也遇到过这样的需求：
要通过请求 [接口C] 获取想要的数据，
但是，必须先通过网络请求 [接口A] 和 [接口B] ，等返回数据，
再把返回数据作为参数，进行C请求
一、
首先，先来一个错误示范，比如第一个想到的dispatch_group_notify
dispatch_queue_t q = dispatch_get_global_queue(0, 0);
dispatch_group_t g_noti = dispatch_group_create();
dispatch_group_async(g_noti, q, ^{// block_g
// 请求A
dispatch_async(q, ^{// block_task
sleep(2);
NSLog(@"task1 complected.");
});
// 执行完这句话，不等block_task执行结束，block_g就算已经执行完毕了
//（已经把block_task放入并发队列）
});
dispatch_group_async(g_noti, q, ^{
// 请求B
dispatch_async(q, ^{
sleep(1);
NSLog(@"task2 complected.");
});
});
dispatch_group_notify(g_noti, dispatch_get_main_queue(), ^{
NSLog(@"task all complected.");
});
打印结果：
task all complected.
task2 complected.
task1 complected.
可惜的是，发现并没有实现想要的效果。因为dispatch_group_notify的block里面，仅仅是执行了异步dispatch，并不是执行耗时的同步网络请求。
那么，像这样多个异步任务执行完成后，触发统一回调，应该怎么处理呢？
二、
为了方便，自己写了个小工具类，源码下面有写。
糅合了 dispatch_group_notify 和 dispatch_semaphore_signal 的用法，
先看它的用法：
@property XIAsynTaskNoti *noti;
// 1 初始化
_noti = [XIAsynTaskNoti notiWithTaskCount:2];
dispatch_queue_t q = dispatch_get_global_queue(0, 0);
dispatch_async(q, ^{// 网络请求A
sleep(2);
NSLog(@"task1 complected.");
// 2 标记网络请求已经完成，并储存返回数据
[_noti signalChildTaskComplected:@"task1" data:@(1)];
});
dispatch_async(q, ^{// 网络请求B
sleep(1);
NSLog(@"task2 complected.");
[_noti signalChildTaskComplected:@"task2" data:@(2)];
});
// 3 当全部请求完成后，在指定线程回调，再去执行网络请求C
[_noti notifyAt:dispatch_get_main_queue() withBlock:^(id data) {
NSLog(@"task all complected.");
NSLog(@"data : %@",data);
/* data =
@{
@"task1" : @1,
@"task2" = @2
}
*/
// C request...
}];
打印结果：
task2 complected.
task1 complected.
task all complected.
data : {
task1 = 1;
task2 = 2;
}
总结一下使用方法：
1 初始化，需要执行几个任务：+notiWithTaskCount:
2 标记一个任务已经完成：-signalChildTaskComplected: data:
3 回调处理 -notifyAt: withBlock:
三、
下面是源码，实现比较简单：
主要在signalChildTaskComplected: 处理了多线程并发控制，参考了ibireme大大 写的YYKit的源码，使用了互斥锁 pthread_mutex
- XIAsynTaskNoti.h
#import <Foundation/Foundation.h>
/**
* 支持多个异步任务执行完成后，触发统一回调
* 类似 dispatch_group_notify
*/
@interface XIAsynTaskNoti : NSObject
/**
* 返回XIAsynTaskNoti对象
* @param count 子任务数量
*/
+(instancetype)notiWithTaskCount:(NSInteger)count;
/**
* 标记一个子任务已经执行完成
* @param data 子任务返回的数据
* @param dKey 区分哪个子任务的数据
*/
-(void)signalChildTaskComplected:(NSString *)dKey data:(id)data;
/**
* 当子任务都执行完成后，触发block
* @param block 回调block。data=@{..}，可根据dKey，获取子任务返回的数据
*/
-(void)notifyAt:(dispatch_queue_t)queue withBlock:(void(^)(id data))block;
@end
- XIAsynTaskNoti.m
#import "XIAsynTaskNoti.h"
#import <pthread.h>
typedef void (^NotiRecall)(id data);
@interface XIAsynTaskNoti()
@property(nonatomic, strong) NSMutableDictionary *data;
@end
@implementation XIAsynTaskNoti
{
// condiction
NSInteger _taskCount;
NSInteger _curCount;
// concurrent control
pthread_mutex_t _mutexLock;
// notify
dispatch_queue_t _queue;
NotiRecall _recall;
}
+(instancetype)notiWithTaskCount:(NSInteger)count
{
return [[self alloc] initWithTaskCount:count];
}
-(void)notifyAt:(dispatch_queue_t)queue withBlock:(void (^)(id data))block
{
_queue = queue;
_recall = block;
}
-(void)signalChildTaskComplected:(NSString *)dKey data:(id)data
{
BOOL finish = NO;
BOOL notify = NO;
while (!finish) {
// 并发控制用semaphore/NSLock/@synchronize都可以
if (0==pthread_mutex_trylock(&_mutexLock)) {
finish = YES;
if (dKey&&data) self.data[dKey] = data;
if (++_curCount==_taskCount) notify = YES;
pthread_mutex_unlock(&_mutexLock);
}else {
usleep(10*1000);// 暂时挂起该线程10 ms，等待重试。1ms = 1000us
}
}
if(notify) [self notify];
}
-(void)notify
{
dispatch_async(_queue, ^{
_recall(_data);
});
}
-(instancetype)initWithTaskCount:(NSInteger)count
{
if (self = [self init]) {
_taskCount = count;
}
return self;
}
-(instancetype)init
{
if (self = [super init]) {
pthread_mutex_init(&_mutexLock, NULL);
}
return self;
}
-(void)dealloc
{
pthread_mutex_destroy(&_mutexLock);
}
-(NSMutableDictionary *)data
{
if (!_data) {
_data = [@{} mutableCopy];
}
return _data;
}
@end
最近项目没那么忙了，以后要多造轮子。。
网友评论