一、多線程的基本概念
進程：系統進行資源分配和調度的基本單位。
線程：線程是CPU調度的基本單元，一個進程對應多個線程。
同一個進程中可以包括多個線程，並且線程共享整個進程的資源（寄存器、堆棧、上下文），一個進程至少包括一個線程。
主線程：處理UI，所有更新UI的操作都必須在主線程上執行。不要把耗時操作放在主線程，會卡界面。
多線程：在同一時刻，一個CPU只能處理1條線程，但CPU可以在多條線程之間快速的切換，只要切換的足夠快，就造成了多線程一同執行的假象。多線程是通過提高資源使用率來提高系統總體的效率。
二、線程的狀態與生命週期
線程的生命週期是：新建 - 就緒 - 運行 - 阻塞 - 死亡
下面分別闡述線程生命週期中的每一步
新建：實例化線程對象
就緒：向線程對象發送start消息，線程對象被加入可調度線程池等待CPU調度。
運行：CPU 負責調度可調度線程池中線程的執行。線程執行完成之前，狀態可能會在就緒和運行之間來回切換。就緒和運行之間的狀態變化由CPU負責，程序員不能干預。
阻塞：當滿足某個預定條件時，可以使用休眠或鎖，阻塞線程執行。sleepForTimeInterval（休眠指定時長），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥鎖）。
死亡：正常死亡，線程執行完畢。非正常死亡，當滿足某個條件後，在線程內部中止執行/在主線程中止線程對象
還有線程的exit和cancel
[NSThread exit]：一旦強行終止線程，後續的所有代碼都不會被執行。
[thread cancel]取消：並不會直接取消線程，只是給線程對象添加 isCancelled 標記。
三、多線程的四種方式的對比
四、線程安全問題
當多個線程訪問同一塊資源時，很容易引發數據錯亂和數據安全問題。
方法一：互斥鎖（同步鎖）
@synchronized(鎖對象) {
// 需要鎖定的代碼
}
判斷的時候鎖對象要存在，如果代碼中只有一個地方需要加鎖，大多都使用self作爲鎖對象，這樣可以避免單獨再創建一個鎖對象。
加了互斥做的代碼，當新線程訪問時，如果發現其他線程正在執行鎖定的代碼，新線程就會進入休眠。
方法二：自旋鎖
加了自旋鎖，當新線程訪問代碼時，如果發現有其他線程正在鎖定代碼，新線程會用死循環的方式，一直等待鎖定的代碼執行完成。相當於不停嘗試執行代碼，比較消耗性能。
屬性修飾atomic本身就有一把自旋鎖。
下面說一下屬性修飾nonatomic 和 atomic
nonatomic 非原子屬性，同一時間可以有很多線程讀和寫atomic 原子屬性(線程安全)，保證同一時間只有一個線程能夠寫入(但是同一個時間多個線程都可以取值)，atomic 本身就有一把鎖(自旋鎖)atomic：線程安全，需要消耗大量的資源nonatomic：非線程安全，不過效率更高，一般使用nonatomic
五、NSThread的使用
detachNewThreadSelector創建好之後自動啓動
performSelectorInBackground創建好之後也是直接啓動
- (void)viewDidLoad {
[super viewDidLoad];
self.view.backgroundColor = [UIColor whiteColor];
// 如果number=1，則表示在主線程，否則是子線程
//當前線程
NSLog(@"%@", [NSThread currentThread]);
/** 方法一，需要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:nil];
// 線程加入線程池等待CPU調度，時間很快，幾乎是立刻執行
[thread1 start];
/** 方法二，創建好之後自動啓動 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:nil];
/** 方法三，隱式創建，直接啓動 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:nil];
}
- (void)doSomething1:(NSObject *)obj {
NSLog(@"doSomething1:%@", [NSThread currentThread]);
}
- (void)doSomething2:(NSObject *)obj {
NSLog(@"doSomething2:%@", [NSThread currentThread]);
}
- (void)doSomething3:(NSObject *)obj {
NSLog(@"doSomething3:%@", [NSThread currentThread]);
}
類方法補充
//退出線程
[NSThread exit];
//判斷當前線程是否爲主線程
[NSThread isMainThread];
//判斷當前線程是否是多線程
[NSThread isMultiThreaded];
//主線程的對象
NSThread *mainThread = [NSThread mainThread];
NSThread的一些屬性
//線程是否在執行
thread.isExecuting;
//線程是否被取消
thread.isCancelled;
//線程是否完成
thread.isFinished;
//是否是主線程
thread.isMainThread;
//線程的優先級，取值範圍0.0到1.0，默認優先級0.5，1.0表示最高優先級，優先級高，CPU調度的頻率高
thread.threadPriority;
六、GCD的理解與使用
No.1：GCD的特點
GCD會自動利用更多的CPU內核
GCD自動管理線程的生命週期（創建線程，調度任務，銷燬線程等）
程序員只需要告訴 GCD 想要如何執行什麼任務，不需要編寫任何線程管理代碼
No.2：GCD的基本概念
任務（block）：任務就是將要在線程中執行的代碼，將這段代碼用block封裝好，然後將這個任務添加到指定的執行方式（同步執行和異步執行），等待CPU從隊列中取出任務放到對應的線程中執行。
同步（sync）：一個接着一個，前一個沒有執行完，後面不能執行，不開線程。
異步（async）：開啓多個新線程，任務同一時間可以一起執行。異步是多線程的代名詞
隊列：裝載線程任務的隊形結構。(系統以先進先出的方式調度隊列中的任務執行)。在GCD中有兩種隊列：串行隊列和併發隊列。
併發隊列：線程可以同時一起進行執行。實際上是CPU在多條線程之間快速的切換。（併發功能只有在異步（dispatch_async）函數下才有效）
串行隊列：線程只能依次有序的執行。
GCD總結：將任務(要在線程中執行的操作block)添加到隊列(自己創建或使用全局併發隊列)，並且指定執行任務的方式(異步dispatch_async，同步dispatch_sync)
No.3：隊列的創建方法
使用dispatch_queue_create來創建隊列對象，傳入兩個參數，第一個參數表示隊列的唯一標識符，可爲空。第二個參數用來表示串行隊列（DISPATCH_QUEUE_SERIAL）或併發隊列（DISPATCH_QUEUE_CONCURRENT）。
// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 併發隊列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
GCD的隊列還有另外兩種：
主隊列：主隊列負責在主線程上調度任務，如果在主線程上已經有任務正在執行，主隊列會等到主線程空閒後再調度任務。通常是返回主線程更新UI的時候使用。dispatch_get_main_queue()
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 耗時操作放在這裏
dispatch_async(dispatch_get_main_queue(), ^{
// 回到主線程進行UI操作
});
});
全局併發隊列：全局併發隊列是就是一個併發隊列，是爲了讓我們更方便的使用多線程。dispatch_get_global_queue(0, 0)
//全局併發隊列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局併發隊列的優先級
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高優先級
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默認（中）優先級
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低優先級
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 後臺優先級
//iOS8開始使用服務質量，現在獲取全局併發隊列時，可以直接傳0
dispatch_get_global_queue(0, 0);
No.4：同步/異步/任務、創建方式
同步（sync）使用dispatch_sync來表示。
異步（async）使用dispatch_async。
任務就是將要在線程中執行的代碼，將這段代碼用block封裝好。
代碼如下：
// 同步執行任務
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
// 任務放在這個block裏
NSLog(@"我是同步執行的任務");
});
// 異步執行任務
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 任務放在這個block裏
NSLog(@"我是異步執行的任務");
});
No.5：GCD的使用
由於有多種隊列（串行/併發/主隊列）和兩種執行方式（同步/異步），所以他們之間可以有多種組合方式。
串行同步
串行異步
併發同步
併發異步
主隊列同步
主隊列異步
串行同步
執行完一個任務，再執行下一個任務。不開啓新線程。
/** 串行同步 */
- (void)syncSerial {
NSLog(@"\n\n**************串行同步***************\n\n");
// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 同步執行
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"串行同步1 %@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"串行同步2 %@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"串行同步3 %@", [NSThread currentThread]);
}
});
}
串行異步
開啓新線程，但因爲任務是串行的，所以還是按順序執行任務。
/** 串行異步 */
- (void)asyncSerial {
NSLog(@"\n\n**************串行異步***************");
// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 異步執行
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"串行異步1 %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"串行異步2 %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"串行異步3 %@", [NSThread currentThread]);
}
});
}
併發同步
因爲是同步的，所以執行完一個任務，再執行下一個任務。不會開啓新線程。
/** 併發同步 */
- (void)syncConcurrent {
//併發隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
//同步執行
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"併發同步1 %@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"併發同步2 %@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"併發同步3 %@", [NSThread currentThread]);
}
});
}
併發異步
任務交替執行，開啓多線程。
/** 併發異步 */
- (void)asyncConcurrent {
//併發隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
//異步執行
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"併發異步1 %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"併發異步2 %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"併發異步3 %@", [NSThread currentThread]);
}
});
}
主隊列同步
如果在主線程中運用這種方式，則會發生死鎖，程序崩潰。
/** 主隊列同步 */
- (void)syncMain {
NSLog(@"\n**************主隊列同步，放到主線程會死鎖***************\n");
//主隊列
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"主隊列同步1 %@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"主隊列同步2 %@", [NSThread currentThread]);
}
});
}
主隊列同步造成死鎖的原因：
如果在主線程中使用主隊列同步，也就是把任務放到了主線程的隊列中。
而同步對於任務是立刻執行的，那麼當把第一個任務放進主隊列時，它就會立馬執行。
可是主線程現在正在處理syncMain方法，任務需要等syncMain執行完才能執行。
syncMain執行到第一個任務的時候，又要等第一個任務執行完才能往下執行第二個和第三個任務。
這樣syncMain方法和第一個任務就開始了互相等待，形成了死鎖。
主隊列異步
在主線程中任務按順序執行。
/** 主隊列異步 */
- (void)asyncMain {
NSLog(@"\n\n**************主隊列異步***************");
// 主隊列
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"主隊列異步1 %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"主隊列異步2 %@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"主隊列異步3 %@", [NSThread currentThread]);
}
});
}
輸入結果爲在主線程中按順序執行：
主隊列異步1 {number = 1, name = main}
主隊列異步1 {number = 1, name = main}
主隊列異步1 {number = 1, name = main}
主隊列異步2 {number = 1, name = main}
主隊列異步2 {number = 1, name = main}
主隊列異步2 {number = 1, name = main}
主隊列異步3 {number = 1, name = main}
主隊列異步3 {number = 1, name = main}
主隊列異步3 {number = 1, name = main}
GCD線程之間的通訊
開發中需要在主線程上進行UI的相關操作，通常會把一些耗時的操作放在其他線程，比如說圖片文件下載等耗時操作。
當完成了耗時操作之後，需要回到主線程進行UI的處理，這裏就用到了線程之間的通訊。
- (IBAction)communicationBetweenThread:(id)sender {
// 異步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 耗時操作放在這裏，例如下載圖片。（運用線程休眠兩秒來模擬耗時操作）
[NSThread sleepForTimeInterval:2];
NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
NSURL *picURL = [NSURL URLWithString:picURLStr];
NSData *picData = [NSData dataWithContentsOfURL:picURL];
UIImage *image = [UIImage imageWithData:picData];
// 回到主線程處理UI
dispatch_async(dispatch_get_main_queue(), ^{
// 在主線程上添加圖片
self.imageView.image = image;
});
});
}
上面的代碼是在新開的線程中進行圖片的下載，下載完成之後回到主線程顯示圖片。
GCD柵欄
當任務需要異步進行，但是這些任務需要分成兩組來執行，第一組完成之後才能進行第二組的操作。這時候就用了到GCD的柵欄方法dispatch_barrier_async。
- (IBAction)barrierGCD:(id)sender {
// 併發隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 異步執行
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：併發異步1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：併發異步2 %@",[NSThread currentThread]);
}
});
dispatch_barrier_async(queue, ^{
NSLog(@"------------barrier------------%@", [NSThread currentThread]);
NSLog(@"******* 併發異步執行，但是34一定在12後面 *********");
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：併發異步3 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：併發異步4 %@",[NSThread currentThread]);
}
});
}
上面代碼的打印結果如下，開啓了多條線程，所有任務都是併發異步進行。但是第一組完成之後，纔會進行第二組的操作。
柵欄：併發異步1 {number = 3, name = (null)}
柵欄：併發異步2 {number = 6, name = (null)}
柵欄：併發異步1 {number = 3, name = (null)}
柵欄：併發異步2 {number = 6, name = (null)}
柵欄：併發異步1 {number = 3, name = (null)}
柵欄：併發異步2 {number = 6, name = (null)}
------------barrier------------{number = 6, name = (null)}
******* 併發異步執行，但是34一定在12後面 *********
柵欄：併發異步4 {number = 3, name = (null)}
柵欄：併發異步3 {number = 6, name = (null)}
柵欄：併發異步4 {number = 3, name = (null)}
柵欄：併發異步3 {number = 6, name = (null)}
柵欄：併發異步4 {number = 3, name = (null)}
柵欄：併發異步3 {number = 6, name = (null)}
GCD延時執行
當需要等待一會再執行一段代碼時，就可以用到這個方法了：dispatch_after。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 5秒後異步執行
NSLog(@"我已經等待了5秒！");
});
//GCD實現代碼只執行一次使用dispatch_once能保證某段代碼在程序運行過程中只被執行1次。可以用來設計單例。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"程序運行過程中我只執行了一次！");
});
GCD快速迭代
GCD有一個快速迭代的方法dispatch_apply，dispatch_apply可以同時遍歷多個數字。
- (IBAction)applyGCD:(id)sender {
NSLog(@"\n************** GCD快速迭代 ***************\n");
//併發隊列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
//dispatch_apply幾乎同時遍歷多個數字
dispatch_apply(7, queue, ^(size_t index) {
NSLog(@"dispatch_apply：%zd======%@",index, [NSThread currentThread]);
});
}
打印結果如下：
dispatch_apply：0======{number = 1, name = main}
dispatch_apply：1======{number = 1, name = main}
dispatch_apply：2======{number = 1, name = main}
dispatch_apply：3======{number = 1, name = main}
dispatch_apply：4======{number = 1, name = main}
dispatch_apply：5======{number = 1, name = main}
dispatch_apply：6======{number = 1, name = main}
GCD隊列組
異步執行幾個耗時操作，當這幾個操作都完成之後再回到主線程進行操作，就可以用到隊列組了。
隊列組有下面幾個特點：
- 所有的任務會併發的執行(不按序)。
- 所有的異步函數都添加到隊列中，然後再納入隊列組的監聽範圍。
- 使用dispatch_group_notify函數，來監聽上面的任務是否完成，如果完成, 就會調用這個方法。
隊列組示例代碼：
- (void)testGroup {
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"隊列組：有一個耗時操作完成！");
});
dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
NSLog(@"隊列組：有一個耗時操作完成！");
});
dispatch_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"隊列組：前面的耗時操作都完成了，回到主線程進行相關操作");
});
}
打印結果如下：
隊列組：有一個耗時操作完成！
隊列組：有一個耗時操作完成！
隊列組：前面的耗時操作都完成了，回到主線程進行相關操作
至此，GCD的相關內容敘述完畢。下面讓我們繼續學習NSOperation。
七、NSOperation的理解與使用
No.1：NSOperation簡介
NSOperation是基於GCD之上的更高一層封裝，NSOperation需要配合NSOperationQueue來實現多線程。
NSOperation實現多線程的步驟如下：
創建任務：先將需要執行的操作封裝到NSOperation對象中。創建隊列：創建NSOperationQueue。將任務加入到隊列中：將NSOperation對象添加到NSOperationQueue中。
需要注意的是，NSOperation是個抽象類，實際運用時中需要使用它的子類，有三種方式：
- 使用子類NSInvocationOperation
- 使用子類NSBlockOperation
- 定義繼承自NSOperation的子類，通過實現內部相應的方法來封裝任務。
No.2：NSOperation的三種創建方式
NSInvocationOperation的使用
創建NSInvocationOperation對象並關聯方法，之後start。
- (void)testNSInvocationOperation {
// 創建NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object: nil];
[invocationOperation start];
}
- (void)invocationOperation {
NSLog(@"NSInvocationOperation包含的任務，沒有加入隊列========%@", [NSThread currentThread]);
}
打印結果如下，得到結論：程序在主線程執行，沒有開啓新線程。
這是因爲NSOperation多線程的使用需要配合隊列NSOperationQueue，後面會講到NSOperationQueue的使用。
NSInvocationOperation包含的任務，沒有加入隊列========{number = 1, name = main}
NSBlockOperation的使用
把任務放到NSBlockOperation的block中，然後start。
- (void)testNSBlockOperation {
// 把任務放到block中
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation包含的任務，沒有加入隊列========%@", [NSThread currentThread]);
}];
[blockOperation start];
}
執行結果如下，可以看出：主線程執行，沒有開啓新線程。
同樣的，NSBlockOperation可以配合隊列NSOperationQueue來實現多線程。
NSBlockOperation包含的任務，沒有加入隊列========{number = 1, name = main}
但是NSBlockOperation有一個方法addExecutionBlock:，通過這個方法可以讓NSBlockOperation實現多線程。
- (void)testNSBlockOperationExecution {
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation運用blockOperationWithBlock添加主任務========%@", [NSThread currentThread]);
}];
[blockOperation addExecutionBlock:^{
NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務1========%@", [NSThread currentThread]);
}];
[blockOperation addExecutionBlock:^{
NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務2========%@", [NSThread currentThread]);
}];
[blockOperation addExecutionBlock:^{
NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務3========%@", [NSThread currentThread]);
}];
[blockOperation start];
}
執行結果如下，可以看出，NSBlockOperation創建時block中的任務是在主線程執行，而運用addExecutionBlock加入的任務是在子線程執行的。
NSBlockOperation運用addExecutionBlock========{number = 1, name = main}
addExecutionBlock方法添加任務1========{number = 3, name = (null)}
addExecutionBlock方法添加任務3========{number = 5, name = (null)}
addExecutionBlock方法添加任務2========{number = 4, name = (null)}
運用繼承自NSOperation的子類
首先我們定義一個繼承自NSOperation的類，然後重寫它的main方法，之後就可以使用這個子類來進行相關的操作了。
@implementation WHOperation
- (void)main {
for (int i = 0; i < 3; i ++) {
NSLog(@"NSOperation的子類WHOperation======%@", [NSThread currentThread]);
}
}
@end
/*****************回到主控制器使用WHOperation**********************/
- (void)testWHOperation {
WHOperation *operation = [[WHOperation alloc] init];
[operation start];
}
運行結果如下，依然是在主線程執行。
NSOperation的子類WHOperation======{number = 1, name = main}
NSOperation的子類WHOperation======{number = 1, name = main}
NSOperation的子類WHOperation======{number = 1, name = main}
所以，NSOperation是需要配合隊列NSOperationQueue來實現多線程的。下面就來說一下隊列NSOperationQueue。
No.3：隊列NSOperationQueue
NSOperationQueue只有兩種隊列：主隊列、其他隊列。其他隊列包含了串行和併發。
主隊列的創建如下，主隊列上的任務是在主線程執行的。
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
其他隊列（非主隊列）的創建如下，加入到‘非隊列’中的任務默認就是併發，開啓多線程。
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
注意：
非主隊列（其他隊列）可以實現串行或並行。
隊列NSOperationQueue有一個參數叫做最大併發數：maxConcurrentOperationCount。
maxConcurrentOperationCount默認爲-1，直接併發執行，所以加入到‘非隊列’中的任務默認就是併發，開啓多線程。
當maxConcurrentOperationCount爲1時，則表示不開線程，也就是串行。
當maxConcurrentOperationCount大於1時，進行併發執行。
系統對最大併發數有一個限制，所以即使程序員把maxConcurrentOperationCount設置的很大，系統也會自動調整。所以把最大併發數設置的很大是沒有意義的。
No.4：NSOperation + NSOperationQueue
把任務加入隊列，這纔是NSOperation的常規使用方式。
addOperation添加任務到隊列
先創建好任務，然後運用- (void)addOperation:(NSOperation *)op 方法來吧任務添加到隊列中，示例代碼如下：
- (void)testOperationQueue {
// 創建隊列，默認併發
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 創建操作，NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
// 創建操作，NSBlockOperation
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 3; i ++) {
NSLog(@"addOperation把任務添加到隊列======%@", [NSThread currentThread]);
}
}];
[queue addOperation:invocationOperation];
[queue addOperation:blockOperation];
}
- (void)invocationOperationAddOperation {
NSLog(@"invocationOperation===aaddOperation把任務添加到隊列====%@", [NSThread currentThread]);
}
運行結果如下，可以看出，任務都是在子線程執行的，開啓了新線程！
invocationOperation===addOperation把任務添加到隊列===={number = 4, name = (null)}
addOperation把任務添加到隊列======{number = 3, name = (null)}
addOperation把任務添加到隊列======{number = 3, name = (null)}
addOperation把任務添加到隊列======{number = 3, name = (null)}
addOperationWithBlock添加任務到隊列
這是一個更方便的把任務添加到隊列的方法，直接把任務寫在block中，添加到任務中。
- (void)testAddOperationWithBlock {
// 創建隊列，默認併發
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 添加操作到隊列
[queue addOperationWithBlock:^{
for (int i = 0; i < 3; i ++) {
NSLog(@"addOperationWithBlock把任務添加到隊列======%@", [NSThread currentThread]);
}
}];
}
運行結果如下，任務確實是在子線程中執行。
addOperationWithBlock把任務添加到隊列======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======{number = 3, name = (null)}
運用最大併發數實現串行
上面已經說過，可以運用隊列的屬性maxConcurrentOperationCount（最大併發數）來實現串行，值需要把它設置爲1就可以了，下面我們通過代碼驗證一下。
- (void)testMaxConcurrentOperationCount {
// 創建隊列，默認併發
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 最大併發數爲1，串行
queue.maxConcurrentOperationCount = 1;
// 添加操作到隊列
[queue addOperationWithBlock:^{
for (int i = 0; i < 3; i ++) {
NSLog(@"addOperationWithBlock把任務添加到隊列1======%@", [NSThread currentThread]);
}
}];
// 添加操作到隊列
[queue addOperationWithBlock:^{
for (int i = 0; i < 3; i ++) {
NSLog(@"addOperationWithBlock把任務添加到隊列2======%@", [NSThread currentThread]);
}
}];
// 添加操作到隊列
[queue addOperationWithBlock:^{
for (int i = 0; i < 3; i ++) {
NSLog(@"addOperationWithBlock把任務添加到隊列3======%@", [NSThread currentThread]);
}
}];
}
運行結果如下，當最大併發數爲1的時候，雖然開啓了線程，但是任務是順序執行的，所以實現了串行。
你可以嘗試把上面的最大併發數變爲2，會發現任務就變成了併發執行。
addOperationWithBlock把任務添加到隊列1======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======{number = 3, name = (null)}
No.5：NSOperation的其他操作
取消隊列NSOperationQueue的所有操作，NSOperationQueue對象方法
- (void)cancelAllOperations;
取消NSOperation的某個操作，NSOperation對象方法
- (void)cancel;
使隊列暫停或繼續
// 暫停隊列
[queue setSuspended:YES];
判斷隊列是否暫停
- (BOOL)isSuspended;
暫停和取消不是立刻取消當前操作，而是等當前的操作執行完之後不再進行新的操作。
No.6：NSOperation的操作依賴
NSOperation有一個非常好用的方法，就是操作依賴。可以從字面意思理解：某一個操作（operation2）依賴於另一個操作（operation1），只有當operation1執行完畢，才能執行operation2，這時，就是操作依賴大顯身手的時候了。
- (void)testAddDependency {
// 併發隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 操作1
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 3; i ++) {
NSLog(@"operation1======%@", [NSThread currentThread]);
}
}];
// 操作2
NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"****operation2依賴於operation1，只有當operation1執行完畢，operation2纔會執行****");
for (int i = 0; i < 3; i ++) {
NSLog(@"operation2======%@", [NSThread currentThread]);
}
}];
// 操作3
NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"****operation3依賴於operation2，只有當operation2執行完畢，operation3纔會執行****");
for (int i = 0; i < 3; i ++) {
NSLog(@"operation3======%@", [NSThread currentThread]);
}
}];
// 使操作2依賴於操作1
[operation2 addDependency:operation1];
[operation3 addDependency:operation2];
// 把操作加入隊列
[queue addOperation:operation1];
[queue addOperation:operation2];
[queue addOperation:operation3];
}
運行結果如下，操作2總是在操作1之後執行，成功驗證了上面的說法。
operation1======{number = 3, name = (null)}
operation1======{number = 3, name = (null)}
operation1======{number = 3, name = (null)}
****operation2依賴於operation1，只有當operation1執行完畢，operation2纔會執行****
operation2======{number = 4, name = (null)}
operation2======{number = 4, name = (null)}
operation2======{number = 4, name = (null)}