UIGCD的用法，组任务

#import "ViewController.h"

@interface ViewController () {

    dispatch_queue_t suspendQueue;

}

@end

@implementation ViewController

- (void)viewDidLoad {

    [super viewDidLoad];

    // Do any additional setup after loading the view, typically from a nib.

    //[self delayAction];

    //[self suspendQueueAction];

    [self changeTargetQueuePriority];

    

}

- (void)changeTargetQueuePriority {

    //队列的属性和最后一个有关

    //NULL,DISPATCH_QUEUE_SERIAL，串行队列 DISPATCH_QUEUE_CONCURRENT并行队列

    dispatch_queue_t queue1 = dispatch_queue_create("serialQueue1", NULL);

    dispatch_queue_t queue2 = dispatch_queue_create("serialQueue2", NULL);

    dispatch_queue_t queue3 = dispatch_queue_create("serialQueue3", NULL);

    

    dispatch_queue_t targetQueue = dispatch_queue_create("targetQueue", NULL);

    

    //三个队列的优先级作改变为目标Queue,依据目标Queue的类型来决定三个队列中的任务的执行顺序。

    //指定一个queue相应的事件处理提交到targetqueue上执行。这一步的作用只是类似于告知系统要将三个任务添加到串行队列中去。

    dispatch_set_target_queue(queue2, targetQueue);

    dispatch_set_target_queue(queue1, targetQueue);

    dispatch_set_target_queue(queue3, targetQueue);

    

    //分别向三个串行队列中添加三个任务，三个任务是并发执行的。这一步才是向串行队列添加并行任务。就是三个任务直接添加到串行队列了。然后再一个个运行。

    dispatch_async(queue1, ^{

        NSLog(@"queue1 start");

        [NSThread sleepForTimeInterval:3];

        NSLog(@"queue1 end");

        

    });

    

    dispatch_async(queue2, ^{

        NSLog(@"queue2 start");

        [NSThread sleepForTimeInterval:2];

        NSLog(@"queue2 end");

    });

    

    dispatch_async(queue3, ^{

        NSLog(@"queue3 start");

        [NSThread sleepForTimeInterval:1];

        NSLog(@"queue3 end");

    });

    

}

- (void)suspendQueueAction {

    

    suspendQueue = dispatch_queue_create("wxhl.serial", NULL);//创建一个串行队列

    

    dispatch_async(suspendQueue, ^{

        

        [NSThread sleepForTimeInterval:2];//一个串行队列直接就这个任务刚开始就加进去了，然后后面二个任务等着，这时候那挂起的过了一秒进入任务，这时候哪些另外两个还没有执行然后被挂起

        NSLog(@"任务1");

    });

    dispatch_async(suspendQueue, ^{

        [NSThread sleepForTimeInterval:2];

        NSLog(@"任务2");

    });

    dispatch_async(suspendQueue, ^{

        [NSThread sleepForTimeInterval:2];

        NSLog(@"任务3");

    });

    

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

        NSLog(@"挂起当前队列中未执行的任务");

        

        //对当前队列中未执行的任务进行挂起，对已执行的任务无影响

        dispatch_suspend(suspendQueue);

        dispatch_suspend(suspendQueue);

        

    });

    

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

        NSLog(@"恢复之前挂起状态的队列");

        //恢复之前挂起的任务，使其继续执行

        dispatch_resume(suspendQueue);

    });

    

    

    

}

//延迟任务

- (void)delayAction {

    

    NSLog(@"begin");

    //第一个时间相当于一个参照时间，在第一个时间的基础上延迟第二个参数对应的时间

    //第二个时间是ns级别的时间

    double delayInSecond = 2.5;

    dispatch_time_t delayTime = dispatch_time(DISPATCH_TIME_NOW, delayInSecond  * NSEC_PER_SEC);

    

    CFAbsoluteTime beginTime = CFAbsoluteTimeGetCurrent();//当前系统时间

    

    //延迟任务：

//    1.异步追加,不阻塞当前线程。

//    2.延迟添加到队列的时间而不是添加到队列后延迟执行，延迟的时间代表的是添加任务到队列的时间，而不是将任务放到队列中延迟调用

    dispatch_after(delayTime, dispatch_get_main_queue(), ^{

        NSLog(@"delay time:%lf", CFAbsoluteTimeGetCurrent() - beginTime);

    });

    

    NSLog(@"end");

    

   

    

    //[self performSelector:

- (void)barrierTask{

    //10个线程来读10个章节

    //如果要使用barrier_async函数来设置障碍任务，则必须自己创建一个cocurrentQueue，不然你让系统自带的多线程受阻碍则影响其他程序运行。

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

    

    //随机执行

    

    for (int i = 1; i <= 10 ; i++) {

        dispatch_async(queue, ^{

            NSLog(@"读入第%i个章节", i);

            NSLog(@"%@", [NSThread currentThread]);

        });

    }

    

    //1个线程来写这个10个章节中读入的内容,这个障碍就是这个进程直接进行下去，不然按照异步添加的意思是不堵塞的，下面的也运行了，用了这个则堵塞了这个异步程序，类似于串行堵塞，

    dispatch_barrier_async(queue, ^{

        NSLog(@"写入文件");

    });

    

    //继续10个线程来读10个章节

    for (int i = 11; i <= 20 ; i++) {

        dispatch_async(queue, ^{

            NSLog(@"读入第%i个章节", i);

        });

    }

    

}

 

//semaphore

- (void)semaphoreTask {

    

    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    

    array = [[NSMutableArray alloc] init];

    

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);//设置信号量

    

    

    for (int i = 0; i < 100000; i++) {

        dispatch_async(queue, ^{

            

            //信号量为0时等待，大于等于1时减1而不等待

            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);//后面这个是堵塞时间。

            [array addObject:@(i)];

            

            //任务处理完毕，发信号，使信号量+1

            dispatch_semaphore_signal(semaphore);

            

        });

    }

    

    [array addObject:@9999];

    [array addObject:@12];

    

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

        NSSet *set = [NSSet setWithArray:array];

        

        NSLog(@"array.count = %li", array.count);

        NSLog(@"set.count = %li", set.count);//集合不能有重复的

    });

    

}

//多元调用

- (void)efficientLoop {

    

    NSArray *array = @[@6, @"helloworld", @2, @"hi", @3];

    

    //遍历方式

    //1. 快速遍历

//    for (id object in array) {

//        NSLog(@"%@", object);

//    }

    

    //2. 枚举器遍历

    

//    [array enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {

//