为GCD并发队列设置最大并发数

多线程原理（只有一个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]);
        });
    }

控制台打印的是：

可以看出来只有三个线程。