YYDispatchQueuePool原理：
通过维护一个上下文结构体，根据不同QOS优先级创建串行队列（队列数不超过内核），因此在每个串行队列下，线程都会按照先进先出的顺序去执行任务。通过这样就可以控制线程数。
队列和线程之间的关系：
一个队列由一个或多个任务组成，当这些任务要开始执行时，系统会分别把他们分配到某个线程上去执行。当有多个系统核心时，为了高效运行，这些核心会将多个线程分配到各核心上去执行任务。
对于一个并行队列来说，其中的任务可能被分配到多个线程中去执行，即这个并行队列可能对应多个线程。对于串行队列，它每次对应一个线程，这个线程可能不变，可能会被更换。每一时刻，一个线程都只能执行一个任务。一个线程也可能是闲置或者挂起的，因此线程存在时不一定就在执行任务。
iOS8.0之后，队列优先级分为5种
- NSQualityOfServiceUserInteractive：最高优先级, 用于处理 UI 相关的任务
- NSQualityOfServiceUserInitiated：次高优先级, 用于执行需要立即返回的任务
- NSQualityOfServiceUtility：普通优先级，主要用于不需要立即返回的任务
- NSQualityOfServiceBackground：后台优先级，用于处理一些用户不会感知的任务
- NSQualityOfServiceDefault：默认优先级，当没有设置优先级的时候，线程默认优先级
下面是YYDispatchQueuePool里的处理
static inline qos_class_t NSQualityOfServiceToQOSClass(NSQualityOfService qos) {
switch (qos) {
case NSQualityOfServiceUserInteractive: return QOS_CLASS_USER_INTERACTIVE;
case NSQualityOfServiceUserInitiated: return QOS_CLASS_USER_INITIATED;
case NSQualityOfServiceUtility: return QOS_CLASS_UTILITY;
case NSQualityOfServiceBackground: return QOS_CLASS_BACKGROUND;
case NSQualityOfServiceDefault: return QOS_CLASS_DEFAULT;
default: return QOS_CLASS_UNSPECIFIED;
}
}
YYDispatchContext上下文结构体的定义
typedef struct {
const char *name;
void **queues;
//队列数
uint32_t queueCount;
//计数器
int32_t counter;
} YYDispatchContext;
YYDispatchContextCreate 上下文创建
YYDispatchContextRelease 上下文释放
YYDispatchContextGetQueue 根据上下文获取队列
YYDispatchContextGetForQOS 根据QOS优先级获取上下文
YYDispatchContextCreate的实现
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) {
//iOS8.0之后
dispatch_qos_class_t qosClass = NSQualityOfServiceToQOSClass(qos);
for (NSUInteger i = 0; i < queueCount; i++) {
//这里创建的是serial queue串行队列
//不用concurrent queue，主要是因为并行队列会让多个线程同时执行，会大量占用CPU资源
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 {
//iOS8.0之前
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;
}
不使用concurrent queue的原因：避免concurrent queue下，大量线程同时创建、运行、销毁，占用主线程的CPU资源，可能会导致卡顿等问题
下面描述引自YY大神iOS 保持界面流畅的技巧
大量的任务提交到后台队列时，某些任务会因为某些原因被锁住导致线程休眠，或者被阻塞，concurrent queue 随后会创建新的线程来执行其他任务。当这种情况变多时，或者 App 中使用了大量 concurrent queue 来执行较多任务时，App 在同一时刻就会存在几十个线程同时运行、创建、销毁。CPU 是用时间片轮转来实现线程并发的，尽管 concurrent queue 能控制线程的优先级，但当大量线程同时创建运行销毁时，这些操作仍然会挤占掉主线程的 CPU 资源。
YYDispatchContextGetForQOS实现
static YYDispatchContext *YYDispatchContextGetForQOS(NSQualityOfService qos) {
static YYDispatchContext *context[5] = {0};
switch (qos) {
//最高优先级
case NSQualityOfServiceUserInteractive: {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//获取内核数、这里虽然总体能控制了线程数，但不能把CPU发挥到极致
int count = (int)[NSProcessInfo processInfo].activeProcessorCount;
//最大限制了32个
count = count < 1 ? 1 : count > MAX_QUEUE_COUNT ? MAX_QUEUE_COUNT : count;
//创建上下文
context[0] = YYDispatchContextCreate("com.ibireme.yykit.user-interactive", count, qos);
});
return context[0];
} break;
//...more 更多的级别实现基本都类似
default: {
//默认优先级
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
int count = (int)[NSProcessInfo processInfo].activeProcessorCount;
count = count < 1 ? 1 : count > MAX_QUEUE_COUNT ? MAX_QUEUE_COUNT : count;
context[4] = YYDispatchContextCreate("com.ibireme.yykit.default", count, qos);
});
return context[4];
} break;
}
}
