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

控制臺打印的是：

可以看出來只有三個線程。