A B 执行完后执行C

dispatch_async(queue, block1_for_reading)  
dispatch_async(queue, block2_for_reading)

dispatch_barrier_async(queue, block_for_writing)

dispatch_async(queue, block3_for_reading)  
dispatch_async(queue, block4_for_reading) 

    //创建分组

    dispatch_group_t group =dispatch_group_create();

    //创建队列

    dispatch_queue_t queue =dispatch_queue_create("queue",DISPATCH_QUEUE_CONCURRENT);

    //往分组中添加任务

    dispatch_group_async(group, queue, ^{

        [NSThreadsleepForTimeInterval:2];//模拟耗时操作

        NSLog(@"11111 %@", [NSThreadcurrentThread]);

    });

    //往分组中添加任务

    dispatch_group_async(group, queue, ^{

        [NSThreadsleepForTimeInterval:1];//模拟耗时操作

        NSLog(@"2222 %@", [NSThreadcurrentThread]);

    });

    //分组中任务完成以后通知该block执行

    dispatch_group_notify(group, queue, ^{

        NSLog(@"完成 %@", [NSThreadcurrentThread]);

        dispatch_async(dispatch_get_main_queue(), ^{

            NSLog(@"通知主线程刷新UI %@", [NSThreadcurrentThread]);

        });

    });

dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //任务1
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"run task 1");
        sleep(1);
        NSLog(@"complete task 1");
        dispatch_semaphore_signal(semaphore);
    });
    //任务2
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"run task 2");
        sleep(1);
        NSLog(@"complete task 2");
        dispatch_semaphore_signal(semaphore);
    });
    //任务3
    dispatch_async(queue, ^{
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
        NSLog(@"run task 3");
        sleep(1);
        NSLog(@"complete task 3");
        dispatch_semaphore_signal(semaphore);
    });
2019-02-24 18:31:02.447769+0800 Semaphore[33286:12284312] run task 1
2019-02-24 18:31:02.447767+0800 Semaphore[33286:12284310] run task 2
2019-02-24 18:31:03.450756+0800 Semaphore[33286:12284312] complete task 1
2019-02-24 18:31:03.450756+0800 Semaphore[33286:12284310] complete task 2
2019-02-24 18:31:03.450997+0800 Semaphore[33286:12284311] run task 3
2019-02-24 18:31:04.454259+0800 Semaphore[33286:12284311] complete task 3

#pragma mark -依赖关系
-(void)dependcy
{
    /**
     举例场景：
     1. 下载一个小说的压缩包
     2. 解压缩，删除压缩包
     3. 更新UI
     */
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"下载一个小说的压缩包，%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"解压缩，删除压缩包，%@",[NSThread currentThread]);
    }];
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"更新UI，%@",[NSThread currentThread]);
    }];
    // 如果直接把任务添加到队里，会异步执行，使顺序错乱
    
    // 因此需要指定任务之间的依赖关系--------依赖关系可以跨队列(可以在子线程下载完，到主线程更新UI)
    [op2 addDependency:op1];  // op2 依赖于op1  就是执行op2之前必须先执行op1
    [op3 addDependency:op2];  // op3 依赖于op2  就是执行op3之前必须先执行op2
    
    /**
     千万注意：不要造成相互依赖即依赖循环，会造成死锁
     */
    //    [op1 addDependency:op3];
    
    
    // waitUntilFinished 类似于GCD中调度组的通知
    // NO表示不等待当前的队列执行完毕，就执行下面的代码，打印 NSLog(@"任务完成");
    // YES 表示必须等队列内的任务全部执行完毕才执行下面的代码
    [ self.opQueue addOperations:@[op1, op2] waitUntilFinished:YES];
    
    // 在主线程更新UI
    [[NSOperationQueue mainQueue] addOperation:op3];
    
    NSLog(@"任务完成");
}
@end