GCD 小总结

简介：GCD是对多线程、多核开发较完整的封装。在使用GCD的时候，系统会自动根据CPU使用情况进行调度，所以GCD是一个简单易用，但是效果很好的多线程多核开发工具。

串行并发队列

• Dispatch Queue按照追加的顺序（先进先出FIFO，First-In-First-Out）执行处理。

• Queue(队列)：分为串行队列和并行队列，所谓的串行和并行是指任务的执行顺序。
  串行队列上添加A、B、C、D四个任务，任务的执行顺序必然也是A、B、C、D的顺序。
  并发队列上添加A、B、C、D四个任务，sync(同步)操作任务顺序执行；async(异步)操作任务同时执行，而且结束的时间是随机的，每次可能不一样。
• Dispatch Queue 队列几种创建方式
  dispatch_queue_t queue = dispatch_get_main_queue(); //获得主线程的dispatch队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); //获得程序进程缺省产生的并发队列，可设定优先级来选择高、中、低三个优先级队列。
dispatch_queue_t queue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL); //生成一个串行队列，队列中的block按照先进先出（FIFO）的顺序去执行，实际上为单线程执行
dispatch_queue_t queue = dispatch_queue_create("com.dispatch.concurrent", DISPATCH_QUEUE_CONCURRENT); //生成一个并发执行队列，block被分发到多个线程去执行

同步、异步、串行、并发

同步异步代表任务添加的时候会不会立即返回，任务执行的时候会不会开辟新的线程。串行和并发代表任务执行的方式。
同步串行和并发，任务的执行方式是一样的。没有区别，因为没有开辟新的线程，所有的任务都在一条线程中执行。
异步串行和异步并发，任务执行的方式是有区别的，异步主队列不会开辟线程，但是任务依然是异步执行，主线程执行完当前线程的所有任务后，才会去执行异步添加的任务；异步串行会开辟一条新的线程，队列中所有任务按照添加的顺序一个一个执行；异步并发会开辟多条线程，至于具体开辟多少条线程，是由系统决定的，但是所有的任务好像就是同时执行的一样。

GCD-同步函数／异步

• sync(同步)函数

dispatch_sync(queue, ^{
　　//block具体代码
});
//同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。

• async(异步)函数

dispatch_async(queue, ^{
　　//block具体代码
}); //异步执行block，函数立即返回
//同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。

• sync同步／async异步操作注意点
  实际编程经验告诉我们，尽可能避免使用dispatch_sync，嵌套使用时还容易引起程序死锁。

dispatch_sync(queue1, ^{
      dispatch_sync(queue1, ^{
　　　　......
　　});
　　......
　});

不妨思考下，为什么下面代码在主线程中执行会死锁：

dispatch_sync(dispatch_get_main_queue(), ^{
　　......
}); 

那实际运用中，一般可以用dispatch这样来写，常见的网络请求数据多线程执行模型：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
　　//子线程中开始网络请求数据
　　//更新数据模型
　　dispatch_sync(dispatch_get_main_queue(), ^{
　　　　//在主线程中更新UI代码
　　});
});
//程序的后台运行和UI更新代码紧凑，代码逻辑一目了然。

sync/async + queue(几种搭配)

• sync(同步) + queue （主队列／自定义串行队列／并发队列）

sync + 主队列

 dispatch_sync(dispatch_get_main_queue(), ^{
       //do something ...
 });
//主线程被阻塞，任务不会被执行。。。

sync + 自定义串行队列

dispatch_queue_t serialQueue = dispatch_queue_create("com.dispatch.serial", DISPATCH_QUEUE_SERIAL);
for (NSInteger j=0 ; j<10; j++) {
     dispatch_sync(serialQueue, ^{
     //do something ...
    });
 }
//当前线程上顺序(串行)执行任务，不会创建新的线程,任务添加时刻便开始执行

sync + 并发队列

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_sync(globalQueue, ^{
        // do something ...
});
//在当前线程中顺序（串行）执行，没有创建新的线程，任务添加时刻便开始执行

• async(异步) + queue （主队列／自定义串行队列／并发队列）

async + 主队列

   dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"1");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"2");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"3");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"4");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"5");
    });
    dispatch_async(mainQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"6");
    });
    NSLog(@"end");
1.异步任务在主队列上，没有开辟新的线程，任务依然是保持队形的。
2.是异步的但是又没有产生新的线程，这个和之前的异步不太一样，需要留意。
3.dispatch_async方法，往主队列添加了一个异步任务，此时并不阻塞主线程，
主线程立刻返回执行后面的任务。主线程当前的任务完成了，然后从主队列取出下一个任务（刚刚添加的异步任务）来执行

输出结果
async + 自定义串行队列

    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"1");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"2");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"3");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"4");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"5");
    });
    dispatch_async(serialQueue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"6");
    });
//开辟一个新的线程，线程中任务顺序(串行)执行

输出结果
async + 并发队列

 dispatch_async(globalQueue, ^{
            //  taskA
    });
dispatch_async(globalQueue, ^{
            // taskB
dispatch_async(globalQueue, ^{
            // taskC
    });

//会开辟多条线程执行任务，线程数量由系统决定，线程开始和结束的时间都是随机的

总结

• 队列中任务的执行顺序：
  1.串行队列：不管是sync(同步)操作还是async(异步)操作，串行队列中的任务一定是有序执行的，在串行队列中顺序添加任务A-B-C，执行的顺序一定是A-B-C。
  2.并发队列：在sync(同步)操作中一定是顺序执行的，并发队列中添加的任务，有序执行的；在async(异步)操作中，并发队列的任务是并发执行的，没有一定的顺序，任务开始的时间和任务结束的时间都是不确定的。

• sync(同步)操作async(异步)操作线程开启情况
  1.sync操作，不管是串行队列，并发队列一定不开启新的线程。
  2.async操作，主队列不开启线程，异步任务也放在主线程执行；自定义串行队列开启一条线程；并发队开启线程，数量由系统决定。