多线程原理（只有一个CPU的情况）：
- 同一时间，CPU 只能处理1个线程，同一时间只有1个线程在执行；
-
多线程同时执行CPU 在多个线程之间快速的切换，采用时间片轮转法就造成了多线程的“同时”执行的效果
多线程原理示意图.gif
GCD(Grand Central Dispatch)是Apple 开发的一个多核编程的解决方法。Dispatch Queue包括并行队列（Concurrent Dispatch Queue）。并行队列是使用多个线程同时处理多个任务，但是任务仍会按照添加到队列里的顺序开始执行。并行队列执行任务的线程的数量是由系统的状态决定的。在 iOS7 时，使用 GCD 的并行队列， dispatch_async 最大开启的线程一直能控制在6、7条，线程数都是个位数，然而 iOS8后，最大线程数一度可以达到40条、50条。
当有大量的block提交到并行队列里的时候，并行队列可能会创造许多线程，有些任务内部会有全局的锁（如 CoreText 绘制时的 CGFont 内部锁），会导致线程休眠、阻塞；这可能会使并行队列创造更多的线程去执行其他任务，大量的线程会抢占CPU的资源。有的文章提到GCD线程池的最大线程数为64个，所以一旦达到最大值，应用将挂起。
YYDispatchQueuePool
YYDispatchQueuePool使用多个串行队列来代替GCD的并行队列来。需要添加新的任务时，会从创建过的串行队列里通过轮询的方法获取串行队列来添加任务。YYDispatchQueuePool限制了最大的串行队列数量是32，避免使用并行队列时可能会创建大量线程的问题。
YYDispatchQueuePool对象使用YYDispatchContext *_context来管理队列池：
typedef struct {
const char *name;
void **queues;
uint32_t queueCount;
int32_t counter;
} YYDispatchContext;
上面的结构体里的queues是个数组，用来存放创建的串行队列。
static YYDispatchContext *YYDispatchContextCreate(const char *name,
uint32_t queueCount,
NSQualityOfService qos) {
YYDispatchContext *context = calloc(1, sizeof(YYDispatchContext));
if (!context) return NULL;
context->queues = calloc(queueCount, sizeof(void *));
if (!context->queues) {
free(context);
return NULL;
}
if ([UIDevice currentDevice].systemVersion.floatValue >= 8.0) {
dispatch_qos_class_t qosClass = NSQualityOfServiceToQOSClass(qos);
for (NSUInteger i = 0; i < queueCount; i++) {
dispatch_queue_attr_t attr = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, qosClass, 0);
dispatch_queue_t queue = dispatch_queue_create(name, attr);
context->queues[i] = (__bridge_retained void *)(queue);
}
} else {
long identifier = NSQualityOfServiceToDispatchPriority(qos);
for (NSUInteger i = 0; i < queueCount; i++) {
dispatch_queue_t queue = dispatch_queue_create(name, DISPATCH_QUEUE_SERIAL);
dispatch_set_target_queue(queue, dispatch_get_global_queue(identifier, 0));
context->queues[i] = (__bridge_retained void *)(queue);
}
}
context->queueCount = queueCount;
if (name) {
context->name = strdup(name);
}
return context;
}
上面的方法在创建串行队列时指定了队列的优先级，在iOS8以后，可以使用函数dispatch_queue_attr_make_with_qos_class(dispatch_queue_attr_t attr, dispatch_qos_class_t qos_class, int relative_priority)来设置队列的优先级；而在iOS8之前，则需要先创建串行队列，然后使用函数dispatch_set_target_queue(dispatch_object_t object, dispatch_queue_t queue)使object的的优先级与目标队列的优先级一致。
需要获取串行队列时，可以通过下面的方法：
- (dispatch_queue_t)queue {
return YYDispatchContextGetQueue(_context);
}
static dispatch_queue_t YYDispatchContextGetQueue(YYDispatchContext *context) {
uint32_t counter = (uint32_t)OSAtomicIncrement32(&context->counter);
void *queue = context->queues[counter % context->queueCount];
return (__bridge dispatch_queue_t)(queue);
}
Dispatch Semaphores控制并行队列并发数
可以使用信号量来控制一个并行队列的最大并发数。原理大概是使用信号量来控制添加到并行队列的任务来控制并发数。
下面的函数是控制并发队列queue的最大并发数是3：
void dispatch_asyn_limit_3(dispatch_queue_t queue, dispatch_block_t block){
//控制并发数的信号量
static dispatch_semaphore_t limitSemaphore;
//专门控制并发等待的线程
static dispatch_queue_t receiveQueue;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
limitSemaphore = dispatch_semaphore_create(3);
receiveQueue = dispatch_queue_create("receiver", DISPATCH_QUEUE_SERIAL);
});
dispatch_async(receiveQueue, ^{
//若信号量小于0，则会阻塞receiveQueue的线程，控制添加到queue里的任务不会超过三个。
dispatch_semaphore_wait(limitSemaphore, DISPATCH_TIME_FOREVER);
dispatch_async(queue, ^{
if (block) {
block();
}
//block执行完后增加信号量
dispatch_semaphore_signal(limitSemaphore);
})
});
}
运行一下下面的代码，没有限制并行队列的线程数：
dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 10; i++) {
dispatch_async(concurrentQueue, ^{
NSLog(@"%@", [NSThread currentThread]);
});
}
控制台输出是这样的：
可以看出并行队列生成超过了三个线程。
使用上面的函数来限制线程数：
dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrent", DISPATCH_QUEUE_CONCURRENT);
for (int i = 0; i < 10; i++) {
dispatch_asyn_limit_3(concurrentQueue, ^{
NSLog(@"%@", [NSThread currentThread]);
});
}
控制台打印的是：
可以看出来只有三个线程。
