多線程原理(只有一個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]);
});
}
控制臺打印的是:
可以看出來只有三個線程。