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);
参数：

1. 时间(指定时间追加处理到Dispatch Queue)。
2. 队列。
3. 任务。

    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];
    });
}