GCD
Dispatch Group
在多个并行执行的任务全部执行完毕后，想要追加一个结束处理.
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
NSLog(@"task1");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task2");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task3");
});
dispatch_group_notify(group, queue, ^{
NSLog(@"task Done");
});
//打印 (task1-3 无序)
//task1
//task2
//task3
//task Done
dispatch_barrier_sync和dispatch_barrier_async
栅栏函数，等待前面加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。
注意，barrier是不会拦截全局队列的 dispatch_get_global_queue(0, 0)
dispatch_queue_t queue = dispatch_queue_create("com.abc.efd", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"1111111");
});
dispatch_async(queue, ^{
NSLog(@"2222222");
});
dispatch_barrier_async(queue, ^{
NSLog(@"---------");
});
dispatch_async(queue, ^{
NSLog(@"33333");
});
共同点：
- 都会等待在它前面插入队列的任务1、2先执行完
- 都会等待他们自己的任务（0）执行完再执行后面的任务3
不共同点： - 在将任务插入到queue的时候，dispatch_barrier_sync需要等待自己的任务，结束之后才会继续程序，然后插入被写在它后面的任务3，然后执行后面的任务
- 而dispatch_barrier_async将自己的任务，插入到queue之后，不会等待自己的任务结束，它会继续把后面的任务3插入到queue
dispatch_after
延时执行，不是在指定时间之后才开始执行任务，而是在指定时间之后将任务追加到主队列中。
严格来讲，这个时间并不是绝对准确的。
dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block);
参数：
- 时间(指定时间追加处理到Dispatch Queue)。
- 队列。
- 任务。
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3ull *NSEC_PER_SEC);
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"3秒后追加到主线程队列里执行");
});
因为主线程主队列，在主线程RunLoop中执行，所以在每隔1/60秒执行的RunLoop中，任务最快在3秒后执行，最慢在3+1/60秒后执行。如果主队列有大量处理，那么这个时间会更长。
dispatch_once
只执行一次，常用于创建单例，在多线程的环境下，也能保证线程安全
void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);
- 第一个参数用来检查第二个参数所代表的代码块是否已经被调用；
- 第二个参数则是在整个应用程序中仅仅只会被调用一次的代码块；
- dispach_once函数中的代码块仅仅会被运行一次，并且还是线程安全的。
+(MoviePlayer *)Instance {
static MoviePlayer *player;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
player = [[MoviePlayer alloc] init]
});
return player;
}
dispatch_apply
快速迭代，可以在多线程中同时（异步）遍历
//第一个参数为重复次数
//第二个参数为追加对象的Dispatch Queue
//第三个参数为追加的处理。
dispatch_apply(10, queue, ^(size_t index){
NSLog(@"%zu", index);
});
dispatch_apply函数与dispatch_sync函数相同，会等待处理执行结束，因此推荐在dispatch_async函数中非同步地执行dispatch_apply函数
NSArray *array = @[@"1", @"2", @"3", @"4", @"5", @"6"];
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
dispatch_async(queue, ^{
dispatch_apply([array count], queue, ^(size_t index) {
NSLog(@"%zu : %@", index, [array objectAtIndex:index]);
});
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"currentThread = %@", [NSThread currentThread]);
NSLog(@"done");
});
});
Dispatch Group
在多个并行执行的任务全部执行完毕后，想要追加一个结束处理
dispatch_group_notify
监听group中任务的完成状态，当所有任务都执行完后，追加任务到group中并执行
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
NSLog(@"task1");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task2");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task3");
});
dispatch_group_notify(group, queue, ^{
NSLog(@"task Done");
});
//打印 (task1-3 无序)
//task1
//task2
//task3
//task Done
dispatch_group_wait
阻塞当前线程，等待指定的group中的任务执行完成后，才继续往下执行
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
NSLog(@"task1");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task2");
});
dispatch_group_async(group, queue, ^{
NSLog(@"task3");
});
//也可以使用dispatch_group_wait 函数
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"task Done");
DISPATCH_TIME_FOREVER代表永久等待。
//DISPATCH_TIME_FOREVER 永久等待，同样我们可以设置等待的时间
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1ull*NSEC_PER_SEC);
long result = dispatch_group_wait(group, time);
if (result == 0) {
// 属于Dispatch Group 的全部处理执行结束
NSLog(@"task Done");
} else {
// 属于Dispatch Group 的某个处理还在执行中
NSLog(@"task Doing");
}
通过dispatch_group_wait返回值可以判断，是group任务在设置的超时时间内完成，还是超时未完成。
result ==0 代表全部处理完成，非0代表执行超时了。
dispatch_group_enter
表示一个任务追加到group中
dispatch_group_leave
表示一个任务离开group
- (void)viewDidLoad {
[super viewDidLoad];
[self asynchronousTaskTest];
}
/** 异步任务测试 */
- (void)asynchronousTaskTest{
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// ****************** 任务A，异步执行1秒 ************************
dispatch_group_enter(group);
NSLog(@"任务A准备开始");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), queue, ^{
NSLog(@"任务A准备结束-1");
dispatch_group_leave(group);
NSLog(@"任务A已经结束-1");
});
// ****************** 任务B，异步执行2秒 ************************
dispatch_group_enter(group);
NSLog(@"任务B准备开始");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), queue, ^{
NSLog(@"任务B准备结束-2");
dispatch_group_leave(group);
NSLog(@"任务B已经结束-2");
});
// ****************** 任务C，异步执行3秒 ************************
dispatch_group_enter(group);
NSLog(@"任务C准备开始");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), queue, ^{
NSLog(@"任务C准备结束-3");
dispatch_group_leave(group);
NSLog(@"任务C已经结束-3");
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
//模拟耗时操作
[NSThread sleepForTimeInterval:2];
//打印当前线程
NSLog(@"2---%@",[NSThread currentThread]);
}
dispatch_group_leave(group);
});
// ****************** 所有任务完成 ************************
dispatch_group_notify(group, queue, ^{
NSLog(@"所有任务全部完成");
});
}
信号量 dispatch_semaphore
dispatch_semaphore_create
创建信号量并初始化信号总量
dispatch_semaphore_signal
信号量+1
dispatch_semaphore_wait
信号量-1
信号量<0时会一直阻塞所在线程，反之就可以正常执行
多个网络请求同步
1、首先通过网络请求一获取用户useid，之后用userid为参数发起网络请求二。
#pragma mark - 网络请求一
- (void)getuserId:(dispatch_semaphore_t)semaphore{
AFHTTPSessionManager *sessionmanger=[[AFHTTPSessionManager alloc]init];
sessionmanger.responseSerializer=[AFHTTPResponseSerializer serializer];
[sessionmanger POST:@"https://www.baidu.com/" parameters:nil constructingBodyWithBlock:nil progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
NSLog(@"请求成功1%@", [NSThread currentThread]);
useid=@"1234";
dispatch_semaphore_signal(semaphore);
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
NSLog(@"%@",error);
dispatch_semaphore_signal(semaphore);
}];
}
#pragma mark - 网络请求二
- (void)requestwithuserid:(NSString *)userid{
NSDictionary *parms=[NSMutableDictionary dictionary];
[parms setValue:userid forKey:@"userid"];
AFHTTPSessionManager *sessionmanger=[[AFHTTPSessionManager alloc]init];
sessionmanger.responseSerializer=[AFHTTPResponseSerializer serializer];
[sessionmanger POST:@"https://www.baidu.com/" parameters:userid constructingBodyWithBlock:nil progress:nil success:^(NSURLSessionDataTask * _Nonnull task, id _Nullable responseObject) {
NSLog(@"请求成功2");
} failure:^(NSURLSessionDataTask * _Nullable task, NSError * _Nonnull error) {
NSLog(@"%@",error);
}];
}
#pragma mark - 使用信号量实现
- (void)viewDidLoad {
[super viewDidLoad];
dispatch_semaphore_t semaphore= dispatch_semaphore_create(0); // 创建信号量
[self getuserId:semaphore];//获取用户useid
dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);//当前信号量为0，一直等待阻塞线程
[self requestwithuserid:useid];
}
command+R运行一下，没有任何反应。
原因分析：线程卡住了。代码执行到dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER)因为信号量为0，当前线程会被阻塞。而当前线程是主线程，网络请求一成功后回调到主线程，因为主线程被阻塞 造成信号量无法释放，一直卡住。
解决方案就是开启一个异步线程
- (void)viewDidLoad {
[super viewDidLoad];
//创建一个并行队列
dispatch_queue_t queque = dispatch_queue_create("GoyakodCreated", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queque, ^{
dispatch_semaphore_t semaphore= dispatch_semaphore_create(0); // 创建信号量
[self getuserId:semaphore];
dispatch_semaphore_wait(semaphore,DISPATCH_TIME_FOREVER);
[self requestwithuserid:useid];
});
}
