并发任务

Main.m

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[])
{

    @autoreleasepool {
        
        /*
        //dispatch_group_async 使用
        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(@"block1");sleep(2);});
        dispatch_group_async(group, queue, ^{NSLog(@"block2");});
        dispatch_group_async(group, queue, ^{NSLog(@"block3");});
        //结果汇总(两种方法)
        //1.所有任务执行结束汇总,不阻塞当前线程。一般情况下推荐使用这个
//        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//            NSLog(@"done");
//        });
//
        //2.等待永久，直到所有的任务执行结束，中途不能取消，阻塞当前线程
//        dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        //2.1 扩展：等待1秒后汇总结果,不管任务有没有执行完成
        dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 1*NSEC_PER_SEC);
        
        long result = dispatch_group_wait(group, time);
        if (result == 0) {
            //任务全部执行完成
            NSLog(@"任务全部执行完成");
        }else
        {
            //dispatch_group当中的某个任务还在执行中
            NSLog(@"dispatch_group当中的某个任务还在执行中");
        }
        dispatch_release(group);
        NSLog(@"end");
        */
        
        //dispatch_apply 使用
//        NSArray *arr = @[@0, @1, @2, @3, @4, @5];
//        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//        dispatch_async(queue, ^{
//            //第一个参数为次数，第三个参数是要执行的操作，第二个参数是执行操作所在的线程队列
//            dispatch_apply([arr count], queue, ^(size_t index) {
//                NSLog(@"%zu -- %@", index, arr[index]);
//            });
//            
//            //执行更新
//            dispatch_async(dispatch_get_main_queue(), ^{
//                NSLog(@"done");
//            });
//        });
        
        
        /*
         //dispatch_semaphore_t 使用
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
        NSMutableArray *array = [[NSMutableArray alloc] init];
        for (int i = 0; i < 100000; i++) {
            dispatch_async(queue, ^{
                dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
                [array addObject:@(i)];
                dispatch_semaphore_signal(semaphore);
            });
        }
        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
            
            NSSet *set = [NSSet setWithArray:array];
            
            NSLog(@"%lu",(unsigned long)array.count);
            NSLog(@"%lu",set.count);
        });
         
         */
        
        
        /*
         *   创建了一个初使值为3的信号，每一次for循环都会创建一个新的线程，线程结束的时候会发送一个信号，线程创建之前会信号等待，所以当同时创建了3个线程之后，for循环就会阻塞，等待有线程结束之后会增加一个信号才继续执行，如此就形成了对并发的控制
         *
         *   并发数为3的线程队列
         */
        dispatch_group_t group = dispatch_group_create();
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(3);
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        for (int i = 0; i < 30; i++){
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
            dispatch_group_async(group, queue, ^{
                NSLog(@"%i",i);
                sleep(1);
                dispatch_semaphore_signal(semaphore);
            });
        }
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        dispatch_release(group);
        dispatch_release(semaphore);
        
        NSLog(@"end");
        
        [[NSRunLoop currentRunLoop] run];
    }
    return 0;
}