GCD

本文摘录其他文章所写

1、队列和线程的关系

对我们使用者来说，与其说GCD是面向线程的，不如说是面向队列的。 它隐藏了内部线程的调度。
我们所做的仅仅是创建不同的队列，把Block追加到队列中去执行，而队列是FIFO（先进先出）的。
它会按照我们追加的Block的顺序，在综合我们调用的gcd的api（sync、async、dispatch_barrier_async等等），以及根据系统负载来增减线程并发数， 来调度线程执行Block。

例一：我们在主线程中，往一个并行queue，以sync的方式提交了一个Block，结果Block在主线程中执行。

dispatch_queue_t queue1 = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue1, ^{
    NSLog(@"%@",[NSThread currentThread]);
});
输出结果：{number = 1, name = main}

例二：我们在主线程中用aync方式提交一个Block，结果Block在分线程中执行。

dispatch_queue_t queue1 = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue1, ^{
    NSLog(@"%@",[NSThread currentThread]);
});
输出结果：{number = 2, name = (null)}

例三：我们分别用sync和async向主队列提交Block，结果Block都是在主线程中执行：
注意：我们不能直接在主线程用sync如下的形式去提交Block，否则会引起死锁：

    dispatch_sync(dispatch_get_main_queue(), ^{
    NSLog(@"%@",[NSThread currentThread]);
});

我们用sync如下的方式去提交Block：

dispatch_queue_t queue1 = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue1, ^{
    dispatch_sync(dispatch_get_main_queue(), ^{
        NSLog(@"%@",[NSThread currentThread]);
    });
});
输出结果：{number = 1, name = main}

dispatch_async(dispatch_get_main_queue(), ^{
    NSLog(@"%@",[NSThread currentThread]);
});
输出结果：{number = 1, name = main}

总结一下：

• 往主队列提交Block，无论是sync，还是async，都是在主线程中执行。
• 往非主队列中提交，如果是sync，会在当前提交Block的线程中执行。如果是async，则会在分线程中执行。

需要注意以下两点:

• 这里的sync，async并不局限于dispatch_sync、dispatch_async，而指的是GCD中所有同步异步的API。
• 这里我们用的是并行queue，如果用串行queue，结果也是一样的。唯一的区别是并行queue会权衡当前系统负载，去同时并发几条线程去执行Block，而串行queue中，始终只会在同一条线程中执行Block。

2、GCD的死锁

简单举个死锁例子：

dispatch_sync(dispatch_get_main_queue(), ^{
    NSLog(@"任务一");
});
NSLog(@"任务二");

• 首先造成死锁的原因很简单，两个任务间互相等待。

• 如上，在主线程中，往主队列同步提交了任务一。因为往queue中提交Block，总是追加在队列尾部的，而queue执行Block的顺序为先进先出（FIFO），所以任务一需要在当前队列它之前的任务（任务二）全部执行完，才能轮到它。
  而任务二因为任务一的sync，被阻塞了，它需要等任务一执行完才能被执行。两者互相等待对方执行完，才能执行，程序被死锁在这了。
  这里需要注意这里死锁的很重要一个条件也因为主队列是一个串行的队列(主队列中只有一条主线程)。如果我们如下例，在并行队列中提交，则不会造成死锁：

  dispatch_async(dispatch_get_global_queue(0, 0), ^{
  dispatch_sync(dispatch_get_global_queue(0, 0), ^{
      NSLog(@"任务一");
    });
    NSLog(@"任务二");
  });
  

原因是并行队列中任务一虽被提交仍然是在queue的队尾，在任务二之后，但是因为是并行的，所以任务一并不会一直等任务二结束才去执行，而是直接执行完。此时任务二的因为任务一的结束，sync阻塞也就消除，任务二得以执行。

• 上述第一个死锁的例子，我们很简单的改写一下，死锁就被消除了：

    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"任务一");
    });
    NSLog(@"任务二");
  

• 我们在主线程中，往全局队列同步提交了Block，因为全局队列和主队列是两个队列，所以任务一的执行，并不需要等待任务二。所以等任务一结束，任务二也可以被执行。

• 当然这里因为提交Block所在队列，Block被执行的队列是完全不同的两个队列，所以这里用串行queue，也是不会死锁的。

一些sync的阻塞机制：

• sync提交Block，首先是阻塞的当前提交Block的线程（简单理解下就是阻塞sync之后的代码）。例如我们之前举的例子中，sync总是阻塞了任务二的执行。
• 而在队列中，轮到sync提交的Block，仅仅阻塞串行queue，而不会阻塞并行queue。（dispatch_barrier_(a)sync除外，我们后面会讲到。）

总结一下，会引起GCD死锁的行为：

• 如果同步（sync）提交一个Block到一个串行队列，而提交Block这个动作所处的线程，也是在当前队列，就会引起死锁。

3、4个GCD方法的区别：

dispatch_async(, )
dispatch_sync(, )
dispatch_barrier_async(, )
dispatch_barrier_sync(, )

• dispatch_async 、dispatch_sync(, ) 前者异步、后者同步

• dispatch_barrier_async， 它的作用可以用一个词概括－－承上启下，它保证此前的任务都先于自己执行，此后的任务也迟于自己执行。当然它的作用导致它只有在并行队列中有意义。需要注意的是：dispatch_barrier_(a)sync只在自己创建的并发队列上有效，在全局(Global)并发队列、串行队列上，效果跟dispatch_(a)sync效果一样。

     dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
     dispatch_async(queue, ^{
     //读操作
   });
     dispatch_async(queue, ^{
     // 读操作
   });
   dispatch_barrier_async(queue, ^{
       // 写操作
   });
   dispatch_barrier_async(queue, ^{
       // 写操作
   });
   dispatch_async(queue, ^{
       // 读操作
   });
  

这样写操作的时候，始终只有它这一条线程在进行。而读操作一直是并行的。这么做充分利用了多线程的优势，还不需要加锁，减少了相当一部分的性能开销。实现了读写操作的线程安全。

• dispatch_barrier_sync这个方法和dispatch_barrier_async作用几乎一样，都可以在并行queue中当做栅栏。
  唯一的区别就是：dispatch_barrier_sync有GCD的sync共有特性，会阻塞提交Block的当前线程，而dispatch_barrier_async是异步提交，不会阻塞。

• dispatch_sync，我们来讲讲它和dispatch_barrier_sync的区别。二者因为是sync提交，所以都是阻塞当前提交Block线程。而它俩唯一的区别是：dispatch_sync并不能阻塞并行队列

    dispatch_queue_t queue = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(queue, ^{
        dispatch_async(queue, ^{
            NSLog(@"任务二");
        });
        dispatch_async(queue, ^{
            NSLog(@"任务三");
        });
        //睡眠2秒
        [NSThread sleepForTimeInterval:2];
        NSLog(@"任务一");
    });
      输出结果 :
      任务三
       任务二
        任务一
  

而dispatch_barrier_sync可以阻塞并行队列（栅栏作用的体现）：

    dispatch_queue_t queue = dispatch_queue_create("并行", DISPATCH_QUEUE_CONCURRENT);
    dispatch_barrier_sync(queue, ^{
        dispatch_async(queue, ^{
            NSLog(@"任务二");
        });
        dispatch_async(queue, ^{
            NSLog(@"任务三");
        });
        //睡眠2秒
        [NSThread sleepForTimeInterval:2];
        NSLog(@"任务一");
    });
    输出结果 :
    任务一
    任务二
    任务三