Dispatch全局并发管理工具

当我们采用全局并发队列去异步的执行某种操作的时候，或者使用了大量 concurrent queue 来执行较多任务时，这时候系统会 在同一时刻就会存在几十个线程同时运行、创建、销毁动作，这样会对系统的性能造成一定的影响，我在考虑是不能有一个管理机制来控制线程的并发数，有幸我在yykit的作者一篇《iOS 保持界面流畅的技巧》中发现了作者也遇到了此类问题，并且写了一个管理工具YYDispatchQueuePool,通过通读作者的源码，作者的主要思路是:

为不同优先级创建和 CPU 数量相同的 serial queue，每次从 pool 中获取 queue 时，会轮询返回其中一个 queue

抱着学习的态度，我发现作者的类中方法的封装过于冗余，于是自己重新借鉴了作者的思路与方法，重写了一个同样的工具。

#import <Foundation/Foundation.h>

@interface DispatchQueueManager : NSObject

- (instancetype)init UNAVAILABLE_ATTRIBUTE;
- (instancetype)new UNAVAILABLE_ATTRIBUTE;


/**
 return serial queue of default Qos

 @return dispatch_queue
 */
dispatch_queue_t defaultQosQueue();


/**
 return Qos serial queue

 @param qos Qos
 @return dispatch_queue
 */
dispatch_queue_t defaultQueueForQos(NSQualityOfService qos);
@end

DispatchQueueManager这个类我主要的想法是暴露两个方法出来即可，一个是返回default Qos的queue,另一个则是传入指定的优先级返回一个串行queue.
yykit 作者最优秀的地方是对于OC 语言的了解程度达到了大师段位，他善于运用语言的特性，发挥出程序的最大性能。在我最初的的设想中，我是需要创建一个类DispatchContext，来控制queue的获取，而yykit作者他则是通过创建一个结构体来管理,于是我愉快的借鉴他的设计。

typedef struct {
    const char *name;
    void **queues;//存放 queue 地址
    atomic_uint queueCount;
    atomic_uint counter;
} DispatchContext;

其中你可以发现存放queue采用 指针的方式，而不是数组等方式，这样大大优化了程序的性能。

static DispatchContext* CreateDispatchQueue(const char *name,
                                            atomic_uint queueCount,
                                            NSQualityOfService qos)

接下来我么可以愉快的初始化这个管理者了,通过传入队列名，以及队列数和队列的优先级即可创建，这里需要注意的一点事，我们需要将NSQualityOfService和Dispatch优先级进行一下桥接，考虑到苹果已经放弃了ios 8.0以下的支持，我们也就偷懒进行简单的桥接。

static inline dispatch_qos_class_t NSQualityOfServiceConvertToQosClass(NSQualityOfService qos){
    switch (qos) {
        case NSQualityOfServiceUserInteractive:
            return QOS_CLASS_USER_INTERACTIVE;
            break;
        case NSQualityOfServiceUserInitiated:
            return QOS_CLASS_USER_INITIATED;
            break;
        case NSQualityOfServiceUtility:
            return QOS_CLASS_UTILITY;
            break;
        case NSQualityOfServiceBackground:
            return QOS_CLASS_BACKGROUND;
            break;
        case NSQualityOfServiceDefault:
            return QOS_CLASS_DEFAULT;
            break;
        default:
            return QOS_CLASS_UNSPECIFIED;
            break;
    }

}

采用内联函数的也会优化程序的性能。

接下来是创建初始化的过程。

DispatchContext *context = malloc(sizeof(DispatchContext));
    if (!context) return NULL;
    context->queues = calloc(queueCount, sizeof(void*));
    if (!context->queues) {
        free(context);
        context = NULL;
        return NULL;
    }
    dispatch_qos_class_t qosClass = NSQualityOfServiceConvertToQosClass(qos);
    for (atomic_uint i = 0; i< queueCount; i++) {
        dispatch_queue_attr_t att = dispatch_queue_attr_make_with_qos_class(DISPATCH_QUEUE_SERIAL, qosClass, 0);
        dispatch_queue_t queue = dispatch_queue_create(name, att);
        context->queues[i] = (__bridge_retained void *)(queue);
    }
    context->queueCount = queueCount;
    if (name) {
        context->name = strdup(name);
    }
    return context;

上面的代码就是为DispatchContext分配内存空间，初始化的过程，我们可以发现context->queues(void **queues)保存了queue的指针地址，并且根据queueCount创建可控数目的queue.
接下来我们可以再封装一层，根据传入的NSQualityOfService来返回DispatchContext

static DispatchContext* GetDispatchQueue(NSQualityOfService qos){
    
    char *name;
    static DispatchContext *context;
    switch (qos) {
        case NSQualityOfServiceUserInteractive:
            name = "com.dispatch_queue.mark.userInteractive";
            break;
        case NSQualityOfServiceUserInitiated:
            name = "com.dispatch_queue.mark.userInitiated";
            break;
        case NSQualityOfServiceUtility:
            name = "com.dispatch_queue.mark.utility";
            break;
        case NSQualityOfServiceBackground:
            name = "com.dispatch_queue.mark.background";
            break;
        default:
            name = "com.dispatch_queue.mark.default";
            break;
    }
    
    int count = (int)[NSProcessInfo processInfo].activeProcessorCount;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        context = CreateDispatchQueue(name, count, qos);
    });
    
    return context;
}

以上代码创建了内核数相等的队列。

static dispatch_queue_t GetDispatchQueueOfContext(DispatchContext* context){
    
    atomic_uint counter = atomic_fetch_add_explicit(&context->counter,1,memory_order_relaxed);
    return (__bridge dispatch_queue_t)(context->queues[counter % context->queueCount]);
}

如上我们可以优雅的去轮循去获取串行队列了。

dispatch_queue_t defaultQosQueue(){
    
    return GetDispatchQueueOfContext(GetDispatchQueue(NSQualityOfServiceDefault));
}

dispatch_queue_t defaultQueueForQos(NSQualityOfService qos){
    return GetDispatchQueueOfContext(GetDispatchQueue(qos));
}

暴露给外部的接口就可以去获取了。
这样我们一个并发队列的管理工具就简单的完成了，我们可以做一下测试。

测试代码

for (int i = 0; i< 100; i ++) {
        
        dispatch_queue_t queue = defaultQueueForQos(NSQualityOfServiceDefault);
        dispatch_async(queue, ^{
            NSLog(@"%@",[NSThread currentThread]);
        });
    }

看一下打印信息

Dispatch

这样会节省一部分程序的性能。
如果我们普通的去创建队列，这会给系统造成压力

 for (int i = 0; i< 100; i ++) {
        
        dispatch_queue_t queue = dispatch_queue_create("com.mark.dispatch", DISPATCH_QUEUE_SERIAL);
        dispatch_async(queue, ^{
            NSLog(@"%@",[NSThread currentThread]);
        });
    }

queue

以上的管理管理工具就可以解决同一时刻线程的大量创建和销毁的性能问题了。