- (void)viewDidLoad {

    [super viewDidLoad];

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

    

#warning 1.队列概念

    

    // FIFO队列 :即先进先出

    // 不管是串行队列（SerialQueue）还是并发队列（ConcurrentQueue)，都是FIFO队列。也就意味着，任务一定是一个一个地，按照先进先出的顺序来执行。

    

    // 串行队列：在创建队列时，传参数DISPATCH_QUEUE_SERIAL表示创建串行队列。任务会一个一个地执行，只有前一个任务执行完成，才会继续执行下一个任务。串行执行并不是同步执行的意思，一定要注意区分

    

    // 并发队列：在创建队列时，传参数DISPATCH_QUEUE_CONCURRENT表示创建并发队列。并发队列会尽可能多地创建线程去执行任务。并发队列中的任务会按入队的顺序执行任务，但是哪个任务先完成是不确定的。

 

#warning 2.队列类型

//    1.全局队列：苹果预定义的全局并发队列，只能通过苹果提供的API来获取，可以设置优先级。

//    2.主队列：在应用启动的时候，就会自动创建与主线程关联的串行队列，我们也可能获取，不能手动创建。

//    3.手动创建串行队列

//    4.手动创建并发队列

    

#warning 3.死锁(Deadlock)

    // 所谓死锁（Deadlock）是指它们都卡住了，并等待对方完成或执行其它操作。第一个不能完成是因为它在等待第二个的完成。但第二个也不能完成，因为它在等待第一个的完成。

    

#warning 4.获取公共队列

    // dispatch_get_current_queue：在iOS 6.0之后已经废弃，用于获取当前正在执行任务的队列，主要用于调试

    // dispatch_get_main_queue： 最常用的，用于获取应用主线程关联的串行调度队列

    // dispatch_get_global_queue：最常用的，用于获取应用全局共享的并发队列

    

#warning 5.控制并发数

    // 太多并发是会带来很多的风险的。在实际开发中，并不是并发数越多就越好，往往是需要控制其并发数量的。比如，在处理网络请求发数时，通常会设置限制最大并发数为4左右。当并发数量大了，开销也会很大。学过操作系统应该清楚，并发量大了，临界资源访问操作就很难控制，控制不好就会导致死锁等。当我们需要执行循环异步处理任务时，可以考虑使用dispatch_apply来替代

    

    // 例如:

    // 获得全局并发queue

//    dispatch_queue_t gqueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

//    size_t gcount = 10;

//    dispatch_apply(gcount, gqueue, ^(size_t i) {

//        [self uploadImageWithIndex:(NSUInteger)(i)];

//    });

//    

//    - (void)uploadImageWithIndex:(NSUInteger)imageIndex {

//        NSLog(@"上传索引为%lu的图片", imageIndex);

//    }

    

//    打印结果说明顺序是不确定的，可看得出来这是并发执行的：

//    2015-11-24 00:06:11.692 TestGCD[27714:2678984] 上传索引为0的图片

//    2015-11-24 00:06:11.692 TestGCD[27714:2679067] 上传索引为3的图片

//    2015-11-24 00:06:11.692 TestGCD[27714:2678984] 上传索引为4的图片

//    2015-11-24 00:06:11.692 TestGCD[27714:2679064] 上传索引为2的图片

//    2015-11-24 00:06:11.692 TestGCD[27714:2678984] 上传索引为6的图片

//    2015-11-24 00:06:11.692 TestGCD[27714:2679065] 上传索引为1的图片

//    2015-11-24 00:06:11.693 TestGCD[27714:2678984] 上传索引为8的图片

//    2015-11-24 00:06:11.692 TestGCD[27714:2679067] 上传索引为5的图片

//    2015-11-24 00:06:11.693 TestGCD[27714:2679064] 上传索引为7的图片

//    2015-11-24 00:06:11.693 TestGCD[27714:2679065] 上传索引为9的图片

//    

//    注意：dispatch_apply或dispatch_apply_f函数也是在所有迭代完成之后才会返回，因此这两个函数会阻塞当前线程。当我们在主线程中使用时，一定要小心，很容易造成事件无法响应，所以如果循环代码需要一定的时间执行,可考虑在另一个线程中调用这两个函数。如果所传递的参数是串行queue，而且正是执行当前代码的queue,就会产生死锁。

    

    

    

    /****************************************************************************************/

    /****************************************************************************************/

    /****************************************************************************************/

    /****************************************************************************************/

    /****************************************************************************************/

    /****************************************************************************************/

    /****************************************************************************************/

    

    

    [self GCDTest1]; // 全局队列

    

    [self GCDTest15]; // 全局队列优先级

    

    [self GCDTest14]; // 全局队列优先级测试

    

    [self GCDTest4]; // 主队列

    

    [self GCDTest2]; // 创建串行队列

    

    [self GCDTest3]; // 创建并发队列

    

    [self GCDTest5]; // 串行子队列优先级

    

    [self GCDTest6]; // 并行子队列优先级

    

}

- (void)GCDTest1

{

    // 全局队列不需要创建, 只需要直接获取就可以了 例如

    // 参数1:优先级, 参数2:苹果预留的,现在还没使用到

    // dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"1");

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        sleep(2);

        NSLog(@"2");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        sleep(1);

        NSLog(@"3");

    });

    // 任务1是直接执行，任务2是在异步执行过程中被睡眠2秒，任务3在异步执行过程中被睡眠1秒，结果任务3先于任务2执行完成。说明并发执行任务并不需要等待其他任务先执行完。对于这三个任务，是互不干扰的

    

}

- (void)GCDTest2

{

    // 参数1:一个C语言的字符串，是队列的标签，也就是名称，通常是采用com..这样的格式

    // 参数2:是指定串行队列还是并发队列 (串行：DISPATCH_QUEUE_SERIAL 并发：DISPATCH_QUEUE_CONCURRENT)

    dispatch_queue_t serialQueue = dispatch_queue_create("com.Mmmz.serial-queue",

                                                         DISPATCH_QUEUE_SERIAL);

    // 添加任务到调度队列

    dispatch_async(serialQueue, ^{

        NSLog(@"串行1");

    });

    // 添加任务到调度队列

    dispatch_async(serialQueue, ^{

        sleep(2);

        NSLog(@"串行2");

    });

    // 添加任务到调度队列

    dispatch_async(serialQueue, ^{

        sleep(1);

        NSLog(@"串行3");

    });

    // 从打印结果可以看出来，任务全在同一个线程中执行，但是并不是在主线程，而是在子线程执行。不过任务执行只有顺序地执行，任务没有执行完毕之前，下一个任务是不能开始的。

}

- (void)GCDTest3

{

    dispatch_queue_t serialQueue = dispatch_queue_create("com.Mmmz.concurrent-queue",

                                                         DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(serialQueue, ^{

        NSLog(@"并行1");

    });

    dispatch_async(serialQueue, ^{

        sleep(2);

        NSLog(@"并行2");

    });

    dispatch_async(serialQueue, ^{

        sleep(1);

        NSLog(@"并行3");

    });

    // 从打印结果可以看出来，任务在三个子线程中执行，且互不干扰，不需要等待其他任务完成，就可以并发地分别去执行！

}

- (void)GCDTest4

{

    dispatch_async(dispatch_get_main_queue(), ^{

        sleep(2);

        NSLog(@"main 1");

    });

    

    dispatch_async(dispatch_get_main_queue(), ^{

        NSLog(@"main 2");

    });

    

    dispatch_async(dispatch_get_main_queue(), ^{

        sleep(1);

        NSLog(@"main 3");

    });

    // 从打印结果可看到执行的顺序是按入队的顺序来执行的。虽然让任务1睡眠2秒再执行，其他任务也只能等待任务1完成，才能继承执行任务2，在任务2执行完成，才能执行任务3。 主线程是串行的.

}

- (void)GCDTest5

{

    // 通过dispatch_set_target_queue将串行队列设置成全局队列的子队列, 全局队列可以设置优先级, 所以子队列也会跟着目标队列有了优先级

    

    // 创建一个串行队列

    dispatch_queue_t serialQueue = dispatch_queue_create("com.Mmmz.serial-queue", DISPATCH_QUEUE_SERIAL);

    // 将这个串行队列的目标队列设置成全局队列, 并设置全局队列优先级

    dispatch_set_target_queue(serialQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0));

    dispatch_async(serialQueue, ^{

        NSLog(@"111");

    });

    dispatch_async(serialQueue, ^{

        NSLog(@"222");

    });

    dispatch_async(serialQueue, ^{

        NSLog(@"333");

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"444");

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"555");

    });

    

//    我们把串行队列放到了优先级为LOW的全局队列中，另外还把任务4、5放到优先级为DEFAULT的全局队列中，所以优先执行任务4、5，最后才执行优先级为低的串行队列中的任务。

//    所以这里设置了优先级后，队列就不一定是按FIFO规则了，出队的顺序就变成了按优先级了。只有当所有的任务都是同一个优先级的情况下，才是FIFO。

}

- (void)GCDTest6

{

    // 思路与串行队列优先级一样

    

    // 创建一个并行队列

    dispatch_queue_t concurrentQueue = dispatch_queue_create("com.Mmmz.concurrency-queue", DISPATCH_QUEUE_CONCURRENT);

    // 将这个并行队列的目标队列设置成全局队列, 并设置全局队列优先级

    dispatch_set_target_queue(concurrentQueue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0));

    dispatch_async(concurrentQueue, ^{

        NSLog(@"11111111");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"22222222");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"33333333");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"44444444");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"55555555");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"66666666");

    });

    dispatch_async(concurrentQueue, ^{

        NSLog(@"77777777");

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"88888888");

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"99999999");

    });

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"!!!!!!!!");

    });

    

    // 打印结果 88888 99999 !!!!!! 肯定先执行, 之后是剩下的

    

    // 并发队列执行任务的顺序是不确定的。对于同一优先级的任务，他们出队的顺序一定是FIFO，先进先出，但是先执行的顺序是不确定的！

}

- (void)GCDTest14

{

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{

        sleep(1);

        NSLog(@"全局4");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{

        sleep(3);

        NSLog(@"全局3");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        sleep(2);

        NSLog(@"全局2");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{

        sleep(5);

        NSLog(@"全局1");

    });

    

    // 打印结果可以看出 优先级只是执行的优先级, 即哪个先执行, 并不是哪个先执行完

}

- (void)GCDTest15

{

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0), ^{

        NSLog(@"全局4");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0), ^{

        NSLog(@"全局3");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        NSLog(@"全局2");

    });

    

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0), ^{

        NSLog(@"全局1");

    });

    

    // 优先级由高到低 DISPATCH_QUEUE_PRIORITY_HIGH > DISPATCH_QUEUE_PRIORITY_DEFAULT > DISPATCH_QUEUE_PRIORITY_LOW > DISPATCH_QUEUE_PRIORITY_BACKGROUND

}