一.概述
1.基本概念
同步與異步的概念
- 同步 必須等待當(dāng)前語句執(zhí)行完畢，才可以執(zhí)行下一個語句。
- 異步 不用等待當(dāng)前語句執(zhí)行完畢，就可以執(zhí)行下一個語句。
進(jìn)程與線程的概念
-
進(jìn)程
- 概念：系統(tǒng)中正在運(yùn)行的應(yīng)用程序。
- 特點(diǎn)：每個進(jìn)程都運(yùn)行在其專用且受保護(hù)的內(nèi)存空間，不同的進(jìn)程之間相互獨(dú)立，互不干擾。
-
線程
- 概念：一個進(jìn)程要想執(zhí)行任務(wù)，必須得有線程 (每一個進(jìn)程至少要有一條線程) 線程是進(jìn)程的基本執(zhí)行單元，一個進(jìn)程的所有任務(wù)都是在線程中執(zhí)行的。
- 特點(diǎn)：一條線程在執(zhí)行任務(wù)的時候是串行(按順序執(zhí)行)的。如果要讓一條線程執(zhí)行多個任務(wù)，那么只能一個一個地按順序執(zhí)行這些任務(wù)。也就是說，在同一時間，一條線程只能執(zhí)行一個任務(wù)
多線程的概念與原理
- 概念：1個進(jìn)程可以開啟多條線程，多條線程可以并發(fā)（同時）執(zhí)行不同的任務(wù)。
- 原理：同一時間，CPU只能處理一條線程，即只有一條線程在工作多線程同時執(zhí)行，其實(shí)是CPU快速地在多條線程之間進(jìn)行切換。如果CPU調(diào)度線程的速度足夠快，就會造成多線程并發(fā)執(zhí)行的”假象”。
多線程的優(yōu)缺點(diǎn)
-
優(yōu)點(diǎn)
- 能適當(dāng)提高程序的執(zhí)行效率。
- 能適當(dāng)提高資源的利用率(CPU、內(nèi)存利用率)
-
缺點(diǎn)
- 開啟線程需要占用一定的內(nèi)存空間（默認(rèn)情況下，每一條線程都占用512KB），如果開啟大量的線程，會占用大量的內(nèi)存空間，從而降低程序的性能。
- 線程越多，CPU在調(diào)度線程上的開銷就越大。
- 線程越多，程序設(shè)計就會更復(fù)雜：比如 線程間通訊、多線程的數(shù)據(jù)共享等。
總結(jié)
????實(shí)際上，使用多線程，由于會開線程，必然就會消耗性能，但是卻可以提高用戶體驗。所以，綜合考慮，在保證良好的用戶體驗的前提下，可以適當(dāng)?shù)亻_線程，一般開3-6條。
????在iOS中每個進(jìn)程啟動后都會建立一個主線程（UI線程），這個線程是其他線程的父線程。由于在iOS中除了主線程，其他子線程是獨(dú)立于Cocoa Touch的，所以只有主線程可以更新UI界面。iOS中多線程使用并不復(fù)雜，關(guān)鍵是如何控制好各個線程的執(zhí)行順序、處理好資源競爭問題。
iOS常見多線程方案
二.iOS常見多線程使用方法
1. Pthreads
pthread 是一套通用的多線程的 API，可以在Unix / Linux / Windows 等系統(tǒng)跨平臺使用，使用 C 語言編寫，需要程序員自己管理線程的生命周期，使用難度較大，我們在 iOS 開發(fā)中幾乎不使用 pthread，但是還是來可以了解一下的。
1.1 使用方法
- 首先要包含頭文件#import <pthread.h>
- 其次要創(chuàng)建線程，并開啟線程執(zhí)行任務(wù)
// 1. 創(chuàng)建線程: 定義一個pthread_t類型變量
pthread_t thread;
// 2. 開啟線程: 執(zhí)行任務(wù)
/*
第一個參數(shù)&thread是線程對象，指向線程標(biāo)識符的指針
第二個是線程屬性，可賦值NULL
第三個run表示指向函數(shù)的指針(run對應(yīng)函數(shù)里是需要在新線程中執(zhí)行的任務(wù))
第四個是運(yùn)行函數(shù)的參數(shù)，可賦值NULL
*/
pthread_create(&thread, NULL, run, NULL);
// 3. 設(shè)置子線程的狀態(tài)設(shè)置為 detached，該線程運(yùn)行結(jié)束后會自動釋放所有資源
pthread_detach(thread);
void * run(void *param) // 新線程調(diào)用方法，里邊為需要執(zhí)行的任務(wù)
{
NSLog(@"%@", [NSThread currentThread]);
return NULL;
}
1.2 pthread其它方法
* pthread_create() 創(chuàng)建一個線程
* pthread_exit() 終止當(dāng)前線程
* pthread_cancel() 中斷另外一個線程的運(yùn)行
* pthread_join() 阻塞當(dāng)前的線程，直到另外一個線程運(yùn)行結(jié)束
* pthread_attr_init() 初始化線程的屬性
* pthread_attr_setdetachstate() 設(shè)置脫離狀態(tài)的屬性（決定這個線程在終止時是否可以被結(jié)合）
* pthread_attr_getdetachstate() 獲取脫離狀態(tài)的屬性
* pthread_attr_destroy() 刪除線程的屬性
* pthread_kill() 向指定的線程發(fā)送信號
2. NSThread
NSThread 是蘋果官方提供的，使用起來比 pthread 更加面向?qū)ο?，簡單易用，可以直接操作線程對象。不過也需要需要程序員自己管理線程的生命周期(主要是創(chuàng)建)，我們在開發(fā)的過程中偶爾使用NSThread。比如我們會經(jīng)常調(diào)用[NSThread currentThread]來顯示當(dāng)前的進(jìn)程信息。
2.1 介紹
- 基于thread封裝，添加面向?qū)ο蟾拍睿阅茌^差，偏向底層
- 相對于GCD和NSOperation來說是較輕量級的線程開發(fā)
- 使用比較簡單，但是需要手動管理創(chuàng)建線程的生命周期、同步、異步、加鎖等問題
2.2 線程初始化方法
- 先創(chuàng)建線程，再啟動線程
// 1. 創(chuàng)建線程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
// 2. 啟動線程
[thread start]; // 線程一啟動，就會在線程thread中執(zhí)行self的run方法
// 新線程調(diào)用方法，里邊為需要執(zhí)行的任務(wù)
- (void)run {
NSLog(@"%@", [NSThread currentThread]);
}
- 創(chuàng)建線程后自動啟動線程
// 1. 創(chuàng)建線程后自動啟動線程
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
// 新線程調(diào)用方法，里邊為需要執(zhí)行的任務(wù)
- (void)run {
NSLog(@"%@", [NSThread currentThread]);
}
- 隱式創(chuàng)建并啟動線程
// 1. 隱式創(chuàng)建并啟動線程
[self performSelectorInBackground:@selector(run) withObject:nil];
// 新線程調(diào)用方法，里邊為需要執(zhí)行的任務(wù)
- (void)run {
NSLog(@"%@", [NSThread currentThread]);
}
2.3 線程其它方法
// 獲得主線程
+ (NSThread *)mainThread;
// 判斷是否為主線程(對象方法)
- (BOOL)isMainThread;
// 判斷是否為主線程(類方法)
+ (BOOL)isMainThread;
// 獲得當(dāng)前線程
NSThread *current = [NSThread currentThread];
// 線程的名字——setter方法
- (void)setName:(NSString *)n;
// 線程的名字——getter方法
- (NSString *)name;
2.4 線程狀態(tài)控制方法
// - 啟動線程的方法
- (void)start;
// 線程進(jìn)入就緒狀態(tài) -> 運(yùn)行狀態(tài)。當(dāng)線程任務(wù)執(zhí)行完畢，自動進(jìn)入死亡狀態(tài)
// - 阻塞（暫停）線程方法
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 線程進(jìn)入阻塞狀態(tài)
// - 強(qiáng)制停止線程
+ (void)exit;
// 線程進(jìn)入死亡狀態(tài)
2.5 NSThread線程之間的通信
// 在主線程上執(zhí)行操作
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray<NSString *> *)array;
// equivalent to the first method with kCFRunLoopCommonModes
// 在指定線程上執(zhí)行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array NS_AVAILABLE(10_5, 2_0);
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait NS_AVAILABLE(10_5, 2_0);
// 在當(dāng)前線程上執(zhí)行操作，調(diào)用 NSObject 的 performSelector:相關(guān)方法
- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;
2.6 線程安全
線程安全解決方案：可以給線程加鎖，在一個線程執(zhí)行該操作的時候，不允許其他線程進(jìn)行操作。iOS 實(shí)現(xiàn)線程加鎖有很多種方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各種方式。
2.7 線程的狀態(tài)轉(zhuǎn)換
- 如果CPU現(xiàn)在調(diào)度當(dāng)前線程對象，則當(dāng)前線程對象進(jìn)入運(yùn)行狀態(tài)，如果CPU調(diào)度其他線程對象，則當(dāng)前線程對象回到就緒狀態(tài)。
- 如果CPU在運(yùn)行當(dāng)前線程對象的時候調(diào)用了sleep方法\等待同步鎖，則當(dāng)前線程對象就進(jìn)入了阻塞狀態(tài)，等到sleep到時\得到同步鎖，則回到就緒狀態(tài)。
- 如果CPU在運(yùn)行當(dāng)前線程對象的時候線程任務(wù)執(zhí)行完畢\異常強(qiáng)制退出，則當(dāng)前線程對象進(jìn)入死亡狀態(tài)。
狀態(tài)轉(zhuǎn)換圖
3.GCD
3.1 GCD的優(yōu)點(diǎn)
- GCD 可用于多核的并行運(yùn)算
- GCD 會自動利用更多的 CPU 內(nèi)核（比如雙核、四核）
- GCD 會自動管理線程的生命周期（創(chuàng)建線程、調(diào)度任務(wù)、銷毀線程）
- 程序員只需要告訴 GCD 想要執(zhí)行什么任務(wù)，不需要編寫任何線程管理代碼
3.2 GCD核心概念——任務(wù)和隊列
任務(wù)：就是執(zhí)行操作的意思，換句話說就是你在線程中執(zhí)行的那段代碼。在 GCD 中是放在 block 中的。執(zhí)行任務(wù)有兩種方式：同步執(zhí)行（sync）和異步執(zhí)行（async）。兩者的主要區(qū)別是：是否等待隊列的任務(wù)執(zhí)行結(jié)束，以及是否具備開啟新線程的能力。
-
同步執(zhí)行（sync）
- 同步添加任務(wù)到指定的隊列中，在添加的任務(wù)執(zhí)行結(jié)束之前，會一直等待，直到隊列里面的任務(wù)完成之后再繼續(xù)執(zhí)行。
- 只能在當(dāng)前線程中執(zhí)行任務(wù)，不具備開啟新線程的能力。
-
異步執(zhí)行（async）
- 異步添加任務(wù)到指定的隊列中，它不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)。
- 可以在新的線程中執(zhí)行任務(wù)，具備開啟新線程的能力。
隊列：這里的隊列指執(zhí)行任務(wù)的等待隊列，即用來存放任務(wù)的隊列。隊列是一種特殊的線性表，采用 FIFO（先進(jìn)先出）的原則，即新任務(wù)總是被插入到隊列的末尾，而讀取任務(wù)的時候總是從隊列的頭部開始讀取。每讀取一個任務(wù)，則從隊列中釋放一個任務(wù)。
在 GCD 中有兩種隊列：串行隊列和并發(fā)隊列。兩者都符合 FIFO（先進(jìn)先出）的原則。兩者的主要區(qū)別是：執(zhí)行順序不同，以及開啟線程數(shù)不同。
-
串行隊列（Serial Dispatch Queue）
- 每次只有一個任務(wù)被執(zhí)行。讓任務(wù)一個接著一個地執(zhí)行。（只開啟一個線程，一個任務(wù)執(zhí)行完畢后，再執(zhí)行下一個任務(wù)）
-
并發(fā)隊列（Concurrent Dispatch Queue）
- 可以讓多個任務(wù)并發(fā)（同時）執(zhí)行。（可以開啟多個線程，并且同時執(zhí)行任務(wù)）
并發(fā)隊列 的并發(fā)功能只有在異步（dispatch_async）函數(shù)下才有效。
3.3 GCD的使用步驟
- 創(chuàng)建一個隊列（串行隊列或并發(fā)隊列）
- 將任務(wù)追加到任務(wù)的等待隊列中，然后系統(tǒng)就會根據(jù)任務(wù)類型執(zhí)行任務(wù)（同步執(zhí)行或異步執(zhí)行）
1.隊列的創(chuàng)建方法/獲取方法
- 可以使用dispatch_queue_create來創(chuàng)建隊列，需要傳入兩個參數(shù)，第一個參數(shù)表示隊列的唯一標(biāo)識符，用于 DEBUG，可為空，Dispatch Queue 的名稱推薦使用應(yīng)用程序 ID 這種逆序全程域名；第二個參數(shù)用來識別是串行隊列還是并發(fā)隊列。DISPATCH_QUEUE_SERIAL 表示串行隊列，DISPATCH_QUEUE_CONCURRENT 表示并發(fā)隊列。
// 串行隊列的創(chuàng)建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并發(fā)隊列的創(chuàng)建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
- 對于串行隊列，GCD 提供了的一種特殊的串行隊列：主隊列（Main Dispatch Queue）。
- 所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行。
- 可使用dispatch_get_main_queue()獲得主隊列。
// 主隊列的獲取方法
dispatch_queue_t queue = dispatch_get_main_queue();
- 對于并發(fā)隊列，GCD 默認(rèn)提供了全局并發(fā)隊列（Global Dispatch Queue）。
- 可以使用dispatch_get_global_queue來獲取。需要傳入兩個參數(shù)。第一個參數(shù)表示隊列優(yōu)先級，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二個參數(shù)暫時沒用，用0即可。
// 全局并發(fā)隊列的獲取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
全局并發(fā)隊列與并發(fā)隊列的區(qū)別：
- 全局并發(fā)隊列與并發(fā)隊列的調(diào)度方法相同
- 全局并發(fā)隊列沒有隊列名稱
- 在MRC開發(fā)中，全局并發(fā)隊列不需要手動釋放
2.任務(wù)的創(chuàng)建方法
GCD 提供了同步執(zhí)行任務(wù)的創(chuàng)建方法dispatch_sync和異步執(zhí)行任務(wù)創(chuàng)建方法dispatch_async。
// 同步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_sync(queue, ^{
// 這里放同步執(zhí)行任務(wù)代碼
});
// 異步執(zhí)行任務(wù)創(chuàng)建方法
dispatch_async(queue, ^{
// 這里放異步執(zhí)行任務(wù)代碼
});
雖然使用 GCD 只需兩步，但是既然我們有兩種隊列（串行隊列/并發(fā)隊列），兩種任務(wù)執(zhí)行方式（同步執(zhí)行/異步執(zhí)行），那么我們就有了四種不同的組合方式。再加上兩種特殊隊列：全局并發(fā)隊列、主隊列。全局并發(fā)隊列可以作為普通并發(fā)隊列來使用。但是主隊列因為有點(diǎn)特殊，所以我們就又多了兩種組合方式。這樣就有六種不同的組合方式了。
- 同步執(zhí)行 + 并發(fā)隊列
- 異步執(zhí)行 + 并發(fā)隊列
- 同步執(zhí)行 + 串行隊列
- 異步執(zhí)行 + 串行隊列
- 同步執(zhí)行 + 主隊列
- 異步執(zhí)行 + 主隊列
各種組合的結(jié)果
| 區(qū)別 | 并發(fā)隊列 | 串行隊列 | 主隊列 |
|---|---|---|---|
| 同步(sync) | 沒有開啟新線程，串行執(zhí)行任務(wù) | 沒有開啟新線程，串行執(zhí)行任務(wù) | 沒有開啟新線程，串行執(zhí)行任務(wù) |
| 異步(async) | 有開啟新線程，并發(fā)執(zhí)行任務(wù) | 有開啟新線程(1條)，串行執(zhí)行任務(wù) | 沒有開啟新線程，串行執(zhí)行任務(wù) |
① 并發(fā)隊列 + 同步執(zhí)行
在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
/**
* 同步執(zhí)行 + 并發(fā)隊列
* 特點(diǎn)：在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)syncConcurrent {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_sync(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_sync(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
NSLog(@"syncConcurrent---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> syncConcurrent---begin
------> 1---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> syncConcurrent---end
結(jié)論：
- 所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
- 所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行的（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
- 任務(wù)按順序執(zhí)行的。按順序執(zhí)行的原因：雖然并發(fā)隊列可以開啟多個線程，并且同時執(zhí)行多個任務(wù)。但是因為本身不能創(chuàng)建新線程，只有當(dāng)前線程這一個線程（同步任務(wù)不具備開啟新線程的能力），所以也就不存在并發(fā)。而且當(dāng)前線程只有等待當(dāng)前隊列中正在執(zhí)行的任務(wù)執(zhí)行完畢之后，才能繼續(xù)接著執(zhí)行下面的操作（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。所以任務(wù)只能一個接一個按順序執(zhí)行，不能同時被執(zhí)行。
② 并發(fā)隊列 + 異步執(zhí)行
可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。
/**
* 同步執(zhí)行 + 并發(fā)隊列
* 特點(diǎn)：在當(dāng)前線程中執(zhí)行任務(wù)，不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
/**
* 異步執(zhí)行 + 并發(fā)隊列
* 特點(diǎn)：可以開啟多個線程，任務(wù)交替（同時）執(zhí)行。
*/
- (void)asyncConcurrent {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
NSLog(@"asyncConcurrent---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncConcurrent---begin
------> asyncConcurrent---end
------> 2---<NSThread:>{number = 5, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 2, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 5, name = (null)}
結(jié)論：
- 除了當(dāng)前線程（主線程），系統(tǒng)又開啟了3個線程，并且任務(wù)是交替/同時執(zhí)行的。（異步執(zhí)行具備開啟新線程的能力。且并發(fā)隊列可開啟多個線程，同時執(zhí)行多個任務(wù)）。
- 所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才執(zhí)行的。說明當(dāng)前線程沒有等待，而是直接開啟了新線程，在新線程中執(zhí)行任務(wù)（異步執(zhí)行不做等待，可以繼續(xù)執(zhí)行任務(wù)）。
③ 串行隊列 + 同步執(zhí)行
不會開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
/**
* 同步執(zhí)行 + 串行隊列
* 特點(diǎn)：不會開啟新線程，在當(dāng)前線程執(zhí)行任務(wù)。任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)syncSerial {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_sync(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_sync(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
NSLog(@"syncSerial---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> syncConcurrent---begin
------> 1---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> syncConcurrent---end
結(jié)論：
- 所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（同步執(zhí)行不具備開啟新線程的能力）。
- 所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
- 任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
④ 串行隊列 + 異步執(zhí)行
會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
/**
* 異步執(zhí)行 + 串行隊列
* 特點(diǎn)：會開啟新線程，但是因為任務(wù)是串行的，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)asyncSerial {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
NSLog(@"asyncSerial---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncConcurrent---begin
------> asyncConcurrent---end
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
結(jié)論：
- 開啟了一條新線程（異步執(zhí)行具備開啟新線程的能力，串行隊列只開啟一個線程）。
- 所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
- 任務(wù)是按順序執(zhí)行的（串行隊列每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
- 主隊列：GCD自帶的一種特殊的串行隊列
- 所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行
- 可使用dispatch_get_main_queue()獲得主隊列
⑤ 主隊列 + 同步執(zhí)行
同步執(zhí)行 + 主隊列在不同線程中調(diào)用結(jié)果也是不一樣，在主線程中調(diào)用會出現(xiàn)死鎖，而在其他線程中則不會。
-
在主線程中調(diào)用
互相等待卡住鎖死
/**
* 同步執(zhí)行 + 主隊列
* 特點(diǎn)(主線程調(diào)用)：互等卡主不執(zhí)行。
* 特點(diǎn)(其他線程調(diào)用)：不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
*/
- (void)syncMain {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_sync(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_sync(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
NSLog(@"syncMain---end");
}
結(jié)論：
在主線程中使用同步執(zhí)行 + 主隊列，追加到主線程的任務(wù)1、任務(wù)2、任務(wù)3都不再執(zhí)行了，而且syncMain---end也沒有打印，程序死鎖了。
這是因為我們在主線程中執(zhí)行syncMain方法，相當(dāng)于把syncMain任務(wù)放到了主線程的隊列中。而同步執(zhí)行會等待當(dāng)前隊列中的任務(wù)執(zhí)行完畢，才會接著執(zhí)行。那么當(dāng)我們把任務(wù)1追加到主隊列中，任務(wù)1就在等待主線程處理完syncMain任務(wù)。而syncMain任務(wù)需要等待任務(wù)1執(zhí)行完畢，才能接著執(zhí)行。
那么，現(xiàn)在的情況就是syncMain任務(wù)和任務(wù)1都在等對方執(zhí)行完畢。這樣大家互相等待，所以就卡住了，所以我們的任務(wù)執(zhí)行不了，而且syncMain---end也沒有打印。
-
在其它線程中調(diào)用
不會開啟新線程，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
// 使用 NSThread 的 detachNewThreadSelector 方法會創(chuàng)建線程，并自動啟動線程執(zhí)行
selector 任務(wù)
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 3, name = (null)}
------> syncConcurrent---begin
------> 1---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> syncConcurrent---end
結(jié)論：
- 所有任務(wù)都是在主線程（非當(dāng)前線程）中執(zhí)行的，沒有開啟新的線程（所有放在主隊列中的任務(wù)，都會放到主線程中執(zhí)行）。
- 所有任務(wù)都在打印的syncConcurrent---begin和syncConcurrent---end之間執(zhí)行（同步任務(wù)需要等待隊列的任務(wù)執(zhí)行結(jié)束）。
- 任務(wù)是按順序執(zhí)行的（主隊列是串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
為什么現(xiàn)在就不會卡住了呢？
因為syncMain 任務(wù)放到了其他線程里，而任務(wù)1、任務(wù)2、任務(wù)3都在追加到主隊列中，這三個任務(wù)都會在主線程中執(zhí)行。syncMain 任務(wù)在其他線程中執(zhí)行到追加任務(wù)1到主隊列中，因為主隊列現(xiàn)在沒有正在執(zhí)行的任務(wù)，所以，會直接執(zhí)行主隊列的任務(wù)1，等任務(wù)1執(zhí)行完畢，再接著執(zhí)行任務(wù)2、任務(wù)3。所以這里不會卡住線程。
⑥ 主隊列 + 異步執(zhí)行
只在主線程中執(zhí)行任務(wù)，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)。
/**
* 異步執(zhí)行 + 主隊列
* 特點(diǎn)：只在主線程中執(zhí)行任務(wù)，執(zhí)行完一個任務(wù)，再執(zhí)行下一個任務(wù)
*/
- (void)asyncMain {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
NSLog(@"asyncMain---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncMain---begin
------> asyncMain---end
------> 2---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> 1---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
結(jié)論：
- 所有任務(wù)都是在當(dāng)前線程（主線程）中執(zhí)行的，并沒有開啟新的線程（雖然異步執(zhí)行具備開啟線程的能力，但因為是主隊列，所以所有任務(wù)都在主線程中）。
- 所有任務(wù)是在打印的syncConcurrent---begin和syncConcurrent---end之后才開始執(zhí)行的（異步執(zhí)行不會做任何等待，可以繼續(xù)執(zhí)行任務(wù)）。
- 任務(wù)是按順序執(zhí)行的（因為主隊列是串行隊列，每次只有一個任務(wù)被執(zhí)行，任務(wù)一個接一個按順序執(zhí)行）。
4. GCD線程間的通信
/**
* 線程間通信
*/
- (void)communication {
// 獲取全局并發(fā)隊列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 獲取主隊列
dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 異步追加任務(wù)
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
// 回到主線程
dispatch_async(mainQueue, ^{
// 追加在主線程中執(zhí)行的任務(wù)
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
});
});
}
輸出結(jié)果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 1, name = main}
結(jié)論：
- 可以看到在其他線程中先執(zhí)行任務(wù)，執(zhí)行完了之后回到主線程執(zhí)行主線程的相應(yīng)操作。
5. GCD的其它方法
5.1 GCD 柵欄方法：dispatch_barrier_async
我們有時需要異步執(zhí)行兩組操作，而且第一組操作執(zhí)行完之后，才能開始執(zhí)行第二組操作。這樣我們就需要一個相當(dāng)于 柵欄 一樣的一個方法將兩組異步執(zhí)行的操作組給分割起來，當(dāng)然這里的操作組里可以包含一個或多個任務(wù)。這就需要用到dispatch_barrier_async方法在兩個操作組間形成柵欄。
dispatch_barrier_async函數(shù)會等待前邊追加到并發(fā)隊列中的任務(wù)全部執(zhí)行完畢之后，再將指定的任務(wù)追加到該異步隊列中。然后在dispatch_barrier_async函數(shù)追加的任務(wù)執(zhí)行完畢之后，異步隊列才恢復(fù)為一般動作，接著追加任務(wù)到該異步隊列并開始執(zhí)行。
/**
* 柵欄方法 dispatch_barrier_async
*/
- (void)barrier {
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_barrier_async(queue, ^{
// 追加任務(wù) barrier
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"barrier---%@",[NSThread currentThread]);// 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_async(queue, ^{
// 追加任務(wù)4
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"4---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
}
輸出結(jié)果：
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> barrier---<NSThread:>{number = 4, name = (null)}
------> barrier---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
結(jié)論
- 在執(zhí)行完柵欄前面的操作之后，才執(zhí)行柵欄操作，最后再執(zhí)行柵欄后邊的操作。
5.2 GCD 延時執(zhí)行方法：dispatch_after
我們經(jīng)常會遇到這樣的需求：在指定時間（例如3秒）之后執(zhí)行某個任務(wù)?？梢杂?GCD 的dispatch_after函數(shù)來實(shí)現(xiàn)。
需要注意的是：dispatch_after函數(shù)并不是在指定時間之后才開始執(zhí)行處理，而是在指定時間之后將任務(wù)追加到主隊列中。嚴(yán)格來說，這個時間并不是絕對準(zhǔn)確的，但想要大致延遲執(zhí)行任務(wù)，dispatch_after函數(shù)是很有效的。
/**
* 延時執(zhí)行方法 dispatch_after
*/
- (void)after {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"asyncMain---begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2.0秒后異步追加任務(wù)代碼到主隊列，并開始執(zhí)行
NSLog(@"after---%@",[NSThread currentThread]); // 打印當(dāng)前線程
});
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> asyncMain---begin
------> after---<NSThread:>{number = 1, name = main}
結(jié)論
- 在dispatch_after相關(guān)代碼執(zhí)行結(jié)果中可以看出：在打印 asyncMain---begin 之后大約 2.0 秒的時間，打印了 after---<NSThread:>{number = 1, name = main}
5.3 GCD 一次性代碼（只執(zhí)行一次）：dispatch_once
我們在創(chuàng)建單例、或者有整個程序運(yùn)行過程中只執(zhí)行一次的代碼時，我們就用到了 GCD 的 dispatch_once 函數(shù)。使用
dispatch_once 函數(shù)能保證某段代碼在程序運(yùn)行過程中只被執(zhí)行1次，并且即使在多線程的環(huán)境下，dispatch_once也可以保證線程安全。
/**
* 一次性代碼（只執(zhí)行一次）dispatch_once
*/
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只執(zhí)行1次的代碼(這里面默認(rèn)是線程安全的)
});
}
5.4 GCD 快速迭代方法：dispatch_apply
通常我們會用 for 循環(huán)遍歷，但是 GCD 給我們提供了快速迭代的函數(shù)dispatch_apply。dispatch_apply按照指定的次數(shù)將指定的任務(wù)追加到指定的隊列中，并等待全部隊列執(zhí)行結(jié)束。
我們可以利用異步隊列同時遍歷。比如說遍歷 0~5 這6個數(shù)字，for 循環(huán)的做法是每次取出一個元素，逐個遍歷。dispatch_apply可以同時遍歷多個數(shù)字。
/**
* 快速迭代方法 dispatch_apply
*/
- (void)apply {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"apply---begin");
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd---%@",index, [NSThread currentThread]);
});
NSLog(@"apply---end");
}
輸出結(jié)果：
------> apply---begin
------> 1---<NSThread:>{number = 3, name = (null)}
------> 0---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 5, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
------> 5---<NSThread:>{number = 1, name = main}
------> apply---end
結(jié)論
- 因為是在并發(fā)隊列中異步隊執(zhí)行任務(wù)，所以各個任務(wù)的執(zhí)行時間長短不定，最后結(jié)束順序也不定。但是apply---end一定在最后執(zhí)行。這是因為dispatch_apply函數(shù)會等待全部任務(wù)執(zhí)行完畢。
5.5 GCD 的隊列組：dispatch_group
有時候我們會有這樣的需求：分別異步執(zhí)行2個耗時任務(wù)，然后當(dāng)2個耗時任務(wù)都執(zhí)行完畢后再回到主線程執(zhí)行任務(wù)。這時候我們可以用到 GCD 的隊列組。
- 調(diào)用隊列組的 dispatch_group_async 先把任務(wù)放到隊列中，然后將隊列放入隊列組中?；蛘呤褂藐犃薪M的 dispatch_group_enter、dispatch_group_leave 組合 來實(shí)現(xiàn)
dispatch_group_async。 - 調(diào)用隊列組的 dispatch_group_notify 回到指定線程執(zhí)行任務(wù)?；蛘呤褂?dispatch_group_wait 回到當(dāng)前線程繼續(xù)向下執(zhí)行（會阻塞當(dāng)前線程）。
5.5.1 dispatch_group_notify
監(jiān)聽 group 中任務(wù)的完成狀態(tài)，當(dāng)所有的任務(wù)都執(zhí)行完成后，追加任務(wù)到 group 中，并執(zhí)行任務(wù)。
/**
* 隊列組 dispatch_group_notify
*/
- (void)groupNotify {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的異步任務(wù)1、任務(wù)2都執(zhí)行完畢后，回到主線程執(zhí)行下邊任務(wù)
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
NSLog(@"group---end");
});
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> group---begin
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> group---end
結(jié)論
- 從dispatch_group_notify相關(guān)代碼運(yùn)行輸出結(jié)果可以看出： 當(dāng)所有任務(wù)都執(zhí)行完成之后，才執(zhí)行dispatch_group_notify block 中的任務(wù)。
5.5.2 dispatch_group_wait
暫停當(dāng)前線程（阻塞當(dāng)前線程），等待指定的 group 中的任務(wù)執(zhí)行完成后，才會往下繼續(xù)執(zhí)行。
/**
* 隊列組 dispatch_group_wait
*/
- (void)groupWait {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
});
// 等待上面的任務(wù)全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程）
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"group---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> group---begin
------> 2---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> group---end
結(jié)論
- 從dispatch_group_wait相關(guān)代碼運(yùn)行輸出結(jié)果可以看出： 當(dāng)所有任務(wù)執(zhí)行完成之后，才執(zhí)行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 會阻塞當(dāng)前線程。
5.5.3 dispatch_group_enter、dispatch_group_leave
- dispatch_group_enter 標(biāo)志著一個任務(wù)追加到 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)+1
- dispatch_group_leave 標(biāo)志著一個任務(wù)離開了 group，執(zhí)行一次，相當(dāng)于 group 中未執(zhí)行完畢任務(wù)數(shù)-1。
- 當(dāng) group 中未執(zhí)行完畢任務(wù)數(shù)為0的時候，才會使dispatch_group_wait解除阻塞，以及執(zhí)行追加到dispatch_group_notify中的任務(wù)。
/**
* 隊列組 dispatch_group_enter、dispatch_group_leave
*/
- (void)groupEnterAndLeave
{
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任務(wù)1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任務(wù)2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
dispatch_group_leave(group);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的異步操作都執(zhí)行完畢后，回到主線程.
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印當(dāng)前線程
}
NSLog(@"group---end");
});
// // 等待上面的任務(wù)全部完成后，會往下繼續(xù)執(zhí)行（會阻塞當(dāng)前線程）
// dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//
// NSLog(@"group---end");
}
輸出結(jié)果：
------> currentThread---<NSThread:>{number = 1, name = main}
------> group---begin
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 1, name = main}
------> 3---<NSThread:>{number = 1, name = main}
------> group---end
結(jié)論
- 從dispatch_group_enter、dispatch_group_leave相關(guān)代碼運(yùn)行結(jié)果中可以看出：當(dāng)所有任務(wù)執(zhí)行完成之后，才執(zhí)行 dispatch_group_notify 中的任務(wù)。這里的dispatch_group_enter、dispatch_group_leave組合，其實(shí)等同于dispatch_group_async。
4.NSOperation
4.1 簡介
NSOperation、NSOperationQueue 是蘋果提供給我們的一套多線程解決方案。實(shí)際上 NSOperation、NSOperationQueue 是基于 GCD 更高一層的封裝，完全面向?qū)ο?。但是?GCD 更簡單易用、代碼可讀性也更高。
為什么要使用 NSOperation、NSOperationQueue？
- 可添加完成的代碼塊，在操作完成后執(zhí)行。
- 添加操作之間的依賴關(guān)系，方便的控制執(zhí)行順序。
- 設(shè)定操作執(zhí)行的優(yōu)先級。
- 可以很方便的取消一個操作的執(zhí)行。
- 使用 KVO 觀察對操作執(zhí)行狀態(tài)的更改：isExecuteing、isFinished、isCancelled。
4.2 操作和隊列
既然是基于 GCD 的更高一層的封裝。那么，GCD 中的一些概念同樣適用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有類似的任務(wù)（操作） 和 隊列（操作隊列） 的概念。
-
操作（Operation）
- 執(zhí)行操作的意思，換句話說就是你在線程中執(zhí)行的那段代碼。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，我們使用 NSOperation 子類 NSInvocationOperation、NSBlockOperation，或者自定義子類來封裝操作。
-
操作隊列（Operation Queues）
- 這里的隊列指操作隊列，即用來存放操作的隊列。不同于 GCD 中的調(diào)度隊列 FIFO（先進(jìn)先出）的原則。NSOperationQueue 對于添加到隊列中的操作，首先進(jìn)入準(zhǔn)備就緒的狀態(tài)（就緒狀態(tài)取決于操作之間的依賴關(guān)系），然后進(jìn)入就緒狀態(tài)的操作的開始執(zhí)行順序（非結(jié)束執(zhí)行順序）由操作之間相對的優(yōu)先級決定（優(yōu)先級是操作對象自身的屬性）。
- 操作隊列通過設(shè)置 最大并發(fā)操作數(shù)（maxConcurrentOperationCount） 來控制并發(fā)、串行。
- NSOperationQueue 為我們提供了兩種不同類型的隊列：主隊列和自定義隊列。主隊列運(yùn)行在主線程之上，而自定義隊列在后臺執(zhí)行。
4.3 使用步驟
NSOperation 需要配合 NSOperationQueue 來實(shí)現(xiàn)多線程。因為默認(rèn)情況下，NSOperation 單獨(dú)使用時系統(tǒng)同步執(zhí)行操作，配合 NSOperationQueue 我們能更好的實(shí)現(xiàn)異步執(zhí)行。
- 創(chuàng)建操作：先將需要執(zhí)行的操作封裝到一個 NSOperation 對象中。
- 創(chuàng)建隊列：創(chuàng)建 NSOperationQueue 對象。
- 將操作加入到隊列中：將 NSOperation 對象添加到 NSOperationQueue 對象中。
之后呢，系統(tǒng)就會自動將 NSOperationQueue 中的 NSOperation 取出來，在新線程中執(zhí)行操作。
4.4 NSOperation 和 NSOperationQueue 基本使用
4.4.1 創(chuàng)建操作
NSOperation 是個抽象類，不能用來封裝操作。我們只有使用它的子類來封裝操作。我們有三種方式來封裝操作。
1. 使用子類 NSInvocationOperation
- 在沒有使用 NSOperationQueue、在主線程中單獨(dú)使用使用子類 NSInvocationOperation 執(zhí)行一個操作的情況下，操作是在當(dāng)前線程執(zhí)行的，并沒有開啟新線程。
- 在其他線程中單獨(dú)使用子類 NSInvocationOperation，操作是在當(dāng)前調(diào)用的其他線程執(zhí)行的，并沒有開啟新線程。
// 1.創(chuàng)建 NSInvocationOperation 對象
// 1.創(chuàng)建 NSInvocationOperation 對象
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// 2.調(diào)用 start 方法開始執(zhí)行操作
[op start];
2. 使用子類 NSBlockOperation
- 一個 NSBlockOperation 對象封裝了多個操作。NSBlockOperation 是否開啟新線程，取決于操作的個數(shù)（NSBlockOperation 還提供了一個方法 addExecutionBlock:，通過 addExecutionBlock: 就可以為 NSBlockOperation 添加額外的操作。這些操作（包括 blockOperationWithBlock 中的操作）可以在不同的線程中同時（并發(fā)）執(zhí)行。只有當(dāng)所有相關(guān)的操作已經(jīng)完成執(zhí)行時，才視為完成）。如果添加的操作的個數(shù)多，就會自動開啟新線程。當(dāng)然開啟的線程數(shù)是由系統(tǒng)來決定的。
// 1.創(chuàng)建 NSBlockOperation 對象
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
// do something
}];
// 2.調(diào)用 start 方法開始執(zhí)行操作
[op start];
// 2.添加額外的操作
[op addExecutionBlock:^{
// do something
}];
3. 自定義繼承自 NSOperation 的子類，通過實(shí)現(xiàn)內(nèi)部相應(yīng)的方法來封裝操作。
- 在沒有使用 NSOperationQueue、在主線程單獨(dú)使用自定義繼承自 NSOperation 的子類的情況下，是在主線程執(zhí)行操作，并沒有開啟新線程
如果使用子類 NSInvocationOperation、NSBlockOperation 不能滿足日常需求，我們可以使用自定義繼承自 NSOperation 的子類?？梢酝ㄟ^重寫 main 或者 start 方法 來定義自己的 NSOperation 對象。重寫main方法比較簡單，我們不需要管理操作的狀態(tài)屬性 isExecuting 和 isFinished。當(dāng) main 執(zhí)行完返回的時候，這個操作就結(jié)束了。
//先定義一個繼承自 NSOperation 的子類，重寫main方法。
// JTOperation.h 文件
#import <Foundation/Foundation.h>
@interface JTOperation : NSOperation
@end
// JTOperation.m 文件
#import "JTOperation.h"
@implementation JTOperation
- (void)main {
if (!self.isCancelled) {
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
NSLog(@"1---%@", [NSThread currentThread]);
}
}
}
@end
/**
* 然后使用的時候?qū)腩^文件JTOperation.h。
* 使用自定義繼承自 JTOperation 的子類
*/
- (void)useCustomOperation {
// 1.創(chuàng)建 JTOperation 對象
JTOperation *op = [[JTOperation alloc] init];
// 2.調(diào)用 start 方法開始執(zhí)行操作
[op start];
}
4.4.2 創(chuàng)建隊列
NSOperationQueue 一共有兩種隊列：主隊列、自定義隊列。其中自定義隊列同時包含了串行、并發(fā)功能。下邊是主隊列、自定義隊列的基本創(chuàng)建方法和特點(diǎn)。
- 主隊列
- 凡是添加到主隊列中的操作，都會放到主線程中執(zhí)行。
- 自定義隊列
- 添加到這種隊列中的操作，就會自動放到子線程中執(zhí)行。
- 同時包含了：串行、并發(fā)功能。
// 主隊列獲取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];
// 自定義隊列創(chuàng)建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
4.4.3 將操作加入隊列中
NSOperation 需要配合 NSOperationQueue 來實(shí)現(xiàn)多線程。那么我們需要將創(chuàng)建好的操作加入到隊列中去?？偣灿袃煞N方法：
- *- (void)addOperation:(NSOperation )op;
- 使用 NSOperation 子類創(chuàng)建操作，并使用 addOperation: 將操作加入到操作隊列后能夠開啟新線程，進(jìn)行并發(fā)執(zhí)行。
/**
* 需要先創(chuàng)建操作，再將創(chuàng)建好的操作加入到創(chuàng)建好的隊列中去。
*
* 使用 addOperation: 將操作加入到操作隊列中
*/
- (void)addOperationToQueue {
// 1.創(chuàng)建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.創(chuàng)建操作
// 使用 NSInvocationOperation 創(chuàng)建操作1
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// 使用 NSInvocationOperation 創(chuàng)建操作2
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];
// 使用 NSBlockOperation 創(chuàng)建操作3
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
[op3 addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"4---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
// 3.使用 addOperation: 添加所有操作到隊列中
[queue addOperation:op1]; // [op1 start]
[queue addOperation:op2]; // [op2 start]
[queue addOperation:op3]; // [op3 start]
}
輸出結(jié)果：
------> 4---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 3, name = (null)}
-
- (void)addOperationWithBlock:(void (^)(void))block;
- 使用 addOperationWithBlock: 將操作加入到操作隊列后能夠開啟新線程，進(jìn)行并發(fā)執(zhí)行。
/**
* 無需先創(chuàng)建操作，在 block 中添加操作，直接將包含操作的 block 加入到隊列中。
*
* 使用 addOperation: 將操作加入到操作隊列中
*/
- (void)addOperationWithBlockToQueue {
// 1.創(chuàng)建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.使用 addOperationWithBlock: 添加操作到隊列中
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
}
輸出結(jié)果：
------> 2---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 5, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 5, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
4.5 串行，并行控制
NSOperationQueue 創(chuàng)建的自定義隊列同時具有串行、并發(fā)功能，上邊我們演示了并發(fā)功能。它的串行功能是通過屬性 最大并發(fā)操作數(shù)—maxConcurrentOperationCount 用來控制一個特定隊列中可以有多少個操作同時參與并發(fā)執(zhí)行。
注意：這里 maxConcurrentOperationCount 控制的不是并發(fā)線程的數(shù)量，而是一個隊列中同時能并發(fā)執(zhí)行的最大操作數(shù)。而且一個操作也并非只能在一個線程中運(yùn)行。
- 最大并發(fā)操作數(shù)：maxConcurrentOperationCount
- maxConcurrentOperationCount 默認(rèn)情況下為-1，表示不進(jìn)行限制，可進(jìn)行并發(fā)執(zhí)行。
- maxConcurrentOperationCount 為1時，隊列為串行隊列。只能串行執(zhí)行。
- maxConcurrentOperationCount 大于1時，隊列為并發(fā)隊列。操作并發(fā)執(zhí)行，當(dāng)然這個值不應(yīng)超過系統(tǒng)限制，即使自己設(shè)置一個很大的值，系統(tǒng)也會自動調(diào)整為 min{自己設(shè)定的值，系統(tǒng)設(shè)定的默認(rèn)最大值}。
/**
* 設(shè)置 MaxConcurrentOperationCount（最大并發(fā)操作數(shù)）
*/
- (void)setMaxConcurrentOperationCount {
// 1.創(chuàng)建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.設(shè)置最大并發(fā)操作數(shù)
queue.maxConcurrentOperationCount = 1; // 串行隊列
// queue.maxConcurrentOperationCount = 2; // 并發(fā)隊列
// queue.maxConcurrentOperationCount = 8; // 并發(fā)隊列
// 3.添加操作
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"4---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
}
最大并發(fā)操作數(shù)為1 輸出結(jié)果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 3---<NSThread:>{number = 3, name = (null)}
------> 4---<NSThread:>{number = 4, name = (null)}
------> 4---<NSThread:>{number = 4, name = (null)}
最大并發(fā)操作數(shù)為2 輸出結(jié)果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 4---<NSThread:>{number = 5, name = (null)}
------> 3---<NSThread:>{number = 6, name = (null)}
------> 4---<NSThread:>{number = 5, name = (null)}
------> 3---<NSThread:>{number = 6, name = (null)}
結(jié)論
當(dāng)最大并發(fā)操作數(shù)為1時，操作是按順序串行執(zhí)行的，并且一個操作完成之后，下一個操作才開始執(zhí)行。當(dāng)最大操作并發(fā)數(shù)為2時，操作是并發(fā)執(zhí)行的，可以同時執(zhí)行兩個操作。而開啟線程數(shù)量是由系統(tǒng)決定的，不需要我們來管理。
4.6 NSOperation 操作依賴
NSOperation 提供了3個接口供我們管理和查看依賴。
- *- (void)addDependency:(NSOperation )op; 添加依賴，使當(dāng)前操作依賴于操作 op 的完成。
- *- (void)removeDependency:(NSOperation )op; 移除依賴，取消當(dāng)前操作對操作 op 的依賴。
- **@property (readonly, copy) NSArray<NSOperation > dependencies; 在當(dāng)前操作開始執(zhí)行之前完成執(zhí)行的所有操作對象數(shù)組。
通過添加操作依賴，無論運(yùn)行幾次，其結(jié)果都是 op1 先執(zhí)行，op2 后執(zhí)行。
/**
* 操作依賴
* 使用方法：addDependency:
*/
- (void)addDependency {
// 1.創(chuàng)建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.創(chuàng)建操作
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
// 3.添加依賴
[op2 addDependency:op1]; // 讓op2 依賴于 op1，則先執(zhí)行op1，在執(zhí)行op2
// 4.添加操作到隊列中
[queue addOperation:op1];
[queue addOperation:op2];
}
輸出結(jié)果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
------> 2---<NSThread:>{number = 4, name = (null)}
4.7 NSOperation 優(yōu)先級
NSOperation 提供了queuePriority（優(yōu)先級）屬性，queuePriority屬性適用于同一操作隊列中的操作，不適用于不同操作隊列中的操作。默認(rèn)情況下，所有新創(chuàng)建的操作對象優(yōu)先級都是NSOperationQueuePriorityNormal。但是我們可以通過setQueuePriority:方法來改變當(dāng)前操作在同一隊列中的執(zhí)行優(yōu)先級。
// 優(yōu)先級的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
對于添加到隊列中的操作，首先進(jìn)入準(zhǔn)備就緒的狀態(tài)（就緒狀態(tài)取決于操作之間的依賴關(guān)系），然后進(jìn)入就緒狀態(tài)的操作的開始執(zhí)行順序（非結(jié)束執(zhí)行順序）由操作之間相對的優(yōu)先級決定（優(yōu)先級是操作對象自身的屬性）。
理解了進(jìn)入就緒狀態(tài)的操作，那么我們就理解了queuePriority 屬性的作用對象。
- queuePriority 屬性決定了進(jìn)入準(zhǔn)備就緒狀態(tài)下的操作之間的開始執(zhí)行順序。并且，優(yōu)先級不能取代依賴關(guān)系。
- 如果一個隊列中既包含高優(yōu)先級操作，又包含低優(yōu)先級操作，并且兩個操作都已經(jīng)準(zhǔn)備就緒，那么隊列先執(zhí)行高優(yōu)先級操作。
- 如果，一個隊列中既包含了準(zhǔn)備就緒狀態(tài)的操作，又包含了未準(zhǔn)備就緒的操作，未準(zhǔn)備就緒的操作優(yōu)先級比準(zhǔn)備就緒的操作優(yōu)先級高。那么，雖然準(zhǔn)備就緒的操作優(yōu)先級低，也會優(yōu)先執(zhí)行。優(yōu)先級不能取代依賴關(guān)系。如果要控制操作間的啟動順序，則必須使用依賴關(guān)系。
4.8 NSOperation 線程間通信
/**
* 線程間通信
*/
- (void)communication {
// 1.創(chuàng)建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
// 2.添加操作
[queue addOperationWithBlock:^{
// 異步進(jìn)行耗時操作
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
// 回到主線程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
// 進(jìn)行一些 UI 刷新等操作
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操作
NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
}
}];
}];
}
輸出結(jié)果：
------> 1---<NSThread:>{number = 3, name = (null)}
------> 1---<NSThread:>{number = 3, name = (null)}
------> 2---<NSThread:>{number = 1, name = main}
------> 2---<NSThread:>{number = 1, name = main}
4.9 NSOperation、NSOperationQueue 常用屬性和方法歸納
-
NSOperation 常用屬性和方法
- 取消操作的方法
- - (void)cancel; 可取消操作，實(shí)質(zhì)是標(biāo)記 isCancelled 狀態(tài)。
- 判斷操作狀態(tài)的方法
- - (BOOL)isFinished; 判斷操作是否已經(jīng)結(jié)束。
- - (BOOL)isCancelled; 判斷操作是否已經(jīng)標(biāo)記為取消。
- - (BOOL)isExecuting; 判斷操作是否正在在運(yùn)行。
- - (BOOL)isReady; 判斷操作是否處于準(zhǔn)備就緒狀態(tài)，這個值和操作的依賴關(guān)系相關(guān)。
- 操作同步
- - (void)waitUntilFinished; 阻塞當(dāng)前線程，直到該操作結(jié)束?？捎糜诰€程執(zhí)行順序的同步。
- - (void)setCompletionBlock:(void (^)(void))block; completionBlock 會在當(dāng)前操作執(zhí)行完畢時執(zhí)行 completionBlock。
- *- (void)addDependency:(NSOperation )op; 添加依賴，使當(dāng)前操作依賴于操作 op 的完成。
- *- (void)removeDependency:(NSOperation )op; 移除依賴，取消當(dāng)前操作對操作 op 的依賴。
- **@property (readonly, copy) NSArray<NSOperation > dependencies; 在當(dāng)前操作開始執(zhí)行之前完成執(zhí)行的所有操作對象數(shù)組
- 取消操作的方法
-
NSOperationQueue 常用屬性和方法
- 取消/暫停/恢復(fù)操作
- - (void)cancelAllOperations; 可以取消隊列的所有操作。
- - (BOOL)isSuspended; 判斷隊列是否處于暫停狀態(tài)。 YES 為暫停狀態(tài)，NO 為恢復(fù)狀態(tài)。
- - (void)setSuspended:(BOOL)b; 可設(shè)置操作的暫停和恢復(fù)，YES 代表暫停隊列，NO 代表恢復(fù)隊列。
- 操作同步
- - (void)waitUntilAllOperationsAreFinished; 阻塞當(dāng)前線程，直到隊列中的操作全部執(zhí)行完畢。
- 添加/獲取操作
- - (void)addOperationWithBlock:(void (^)(void))block; 向隊列中添加一個 NSBlockOperation 類型操作對象
- *- (void)addOperations:(NSArray )ops waitUntilFinished:(BOOL)wait; 向隊列中添加操作數(shù)組，wait 標(biāo)志是否阻塞當(dāng)前線程直到所有操作結(jié)束
- *- (NSArray )operations; 當(dāng)前在隊列中的操作數(shù)組（某個操作執(zhí)行結(jié)束后會自動從這個數(shù)組清除）。
- - (NSUInteger)operationCount; 當(dāng)前隊列中的操作數(shù)。
- 獲取隊列
- + (id)currentQueue; 獲取當(dāng)前隊列，如果當(dāng)前線程不是在 NSOperationQueue 上運(yùn)行則返回 nil。
- + (id)mainQueue; 獲取主隊列。
- 取消/暫停/恢復(fù)操作
注意:
- 這里的暫停和取消（包括操作的取消和隊列的取消）并不代表可以將當(dāng)前的操作立即取消，而是當(dāng)當(dāng)前的操作執(zhí)行完畢之后不再執(zhí)行新的操作。
- 暫停和取消的區(qū)別就在于：暫停操作之后還可以恢復(fù)操作，繼續(xù)向下執(zhí)行；而取消操作之后，所有的操作就清空了，無法再接著執(zhí)行剩下的操作。
