多線程的四種解決方案：pthread峡谊，NSThread，GCD，NSOperation
image.png
一示启、多線程的基本概念
進程：可以理解成一個運行中的應用程序，是系統(tǒng)進行資源分配和調度的基本單位领舰，是操作系統(tǒng)結構的基礎夫嗓，主要管理資源。
線程：是進程的基本執(zhí)行單元冲秽，一個進程對應多個線程舍咖。
主線程：處理UI，所有更新UI的操作都必須在主線程上執(zhí)行锉桑。不要把耗時操作放在主線程排霉，會卡界面。
多線程：在同一時刻民轴，一個CPU只能處理1條線程攻柠，但CPU可以在多條線程之間快速的切換球订，只要切換的足夠快，就造成了多線程一同執(zhí)行的假象辙诞。
我們運用多線程的目的是：將耗時的操作放在后臺執(zhí)行辙售！
//--------------------------- <#我是分割線#> ------------------------------//
進程：一個可執(zhí)行的程序
任務：一塊可執(zhí)行的代碼
線程：指的是一個獨立的代碼執(zhí)行路徑轻抱，線程是代碼執(zhí)行路徑的最小分支
串行和并行：串行是一次只能執(zhí)行一個任務飞涂，并行是一次能執(zhí)行多個任務
并行是CPU的多核芯同時執(zhí)行多個任務 并發(fā)是單核CPU交替執(zhí)行兩個任務
//--------------------------- <#我是分割線#> ------------------------------//
一、多線程的基本概念
進程：可以理解成一個運行中的應用程序祈搜，是系統(tǒng)進行資源分配和調度的基本單位较店，是操作系統(tǒng)結構的基礎，主要管理資源容燕。
線程：是進程的基本執(zhí)行單元梁呈，一個進程對應多個線程。
主線程：處理UI蘸秘，所有更新UI的操作都必須在主線程上執(zhí)行官卡。不要把耗時操作放在主線程，會卡界面醋虏。
多線程：在同一時刻寻咒，一個CPU只能處理1條線程，但CPU可以在多條線程之間快速的切換颈嚼，只要切換的足夠快毛秘，就造成了多線程一同執(zhí)行的假象。
線程就像火車的一節(jié)車廂阻课，進程則是火車叫挟。車廂（線程）離開火車（進程）是無法跑動的，而火車（進程）至少有一節(jié)車廂（主線程）限煞。多線程可以看做多個車廂抹恳，它的出現是為了提高效率。
多線程是通過提高資源使用率來提高系統(tǒng)總體的效率署驻。
我們運用多線程的目的是：將耗時的操作放在后臺執(zhí)行适秩！
二、線程的狀態(tài)與生命周期
線程的生命周期是：新建 - 就緒 - 運行 - 阻塞 - 死亡
下面分別闡述線程生命周期中的每一步
新建：實例化線程對象
就緒：向線程對象發(fā)送start消息硕舆，線程對象被加入可調度線程池等待CPU調度秽荞。
運行：CPU 負責調度可調度線程池中線程的執(zhí)行。線程執(zhí)行完成之前抚官，狀態(tài)可能會在就緒和運行之間來回切換扬跋。就緒和運行之間的狀態(tài)變化由CPU負責，程序員不能干預凌节。
阻塞：當滿足某個預定條件時钦听，可以使用休眠或鎖洒试，阻塞線程執(zhí)行。sleepForTimeInterval（休眠指定時長）朴上，sleepUntilDate（休眠到指定日期）垒棋，@synchronized(self)：（互斥鎖）。
死亡：正常死亡痪宰，線程執(zhí)行完畢叼架。非正常死亡，當滿足某個條件后衣撬，在線程內部中止執(zhí)行/在主線程中止線程對象
還有線程的exit和cancel
[NSThread exit]：一旦強行終止線程乖订，后續(xù)的所有代碼都不會被執(zhí)行。
[thread cancel]取消：并不會直接取消線程具练，只是給線程對象添加 isCancelled 標記乍构。
三、多線程的四種解決方案
多線程的四種解決方案分別是：pthread扛点，NSThread哥遮，GCD， NSOperation陵究。
pthread：運用C語言眠饮，是一套通用的API，可跨平臺Unix/Linux/Windows畔乙。線程的生命周期由程序員管理君仆。
NSThread：面向對象，可直接操作線程對象牲距。線程的生命周期由程序員管理返咱。
GCD：代替NSThread，可以充分利用設備的多核牍鞠，自動管理線程生命周期咖摹。
NSOperation：底層是GCD，比GCD多了一些方法难述，更加面向對象萤晴，自動管理線程生命周期。
四胁后、線程安全問題
當多個線程訪問同一塊資源時店读，很容易引發(fā)數據錯亂和數據安全問題。就好比幾個人在同一時修改同一個表格攀芯，造成數據的錯亂屯断。
解決多線程安全問題的方法
方法一：互斥鎖（同步鎖）
@synchronized(鎖對象) {
// 需要鎖定的代碼
}
判斷的時候鎖對象要存在，如果代碼中只有一個地方需要加鎖，大多都使用self作為鎖對象殖演，這樣可以避免單獨再創(chuàng)建一個鎖對象氧秘。
加了互斥做的代碼，當新線程訪問時趴久，如果發(fā)現其他線程正在執(zhí)行鎖定的代碼丸相，新線程就會進入休眠。
方法二：自旋鎖
加了自旋鎖彼棍，當新線程訪問代碼時灭忠，如果發(fā)現有其他線程正在鎖定代碼，新線程會用死循環(huán)的方式滥酥，一直等待鎖定的代碼執(zhí)行完成更舞。相當于不停嘗試執(zhí)行代碼畦幢，比較消耗性能坎吻。
屬性修飾atomic本身就有一把自旋鎖。
下面說一下屬性修飾nonatomic 和 atomic
nonatomic 非原子屬性,同一時間可以有很多線程讀和寫
atomic 原子屬性(線程安全)宇葱，保證同一時間只有一個線程能夠寫入(但是同一個時間多個線程都可以取值)瘦真，atomic 本身就有一把鎖(自旋鎖)
atomic：線程安全，需要消耗大量的資源
nonatomic：非線程安全黍瞧，不過效率更高诸尽，一般使用nonatomic
五、NSThread的使用
No.1：NSThread創(chuàng)建線程
NSThread有三種創(chuàng)建方式：
- init方式
- detachNewThreadSelector創(chuàng)建好之后自動啟動
- performSelectorInBackground創(chuàng)建好之后也是直接啟動
/** 方法一印颤，需要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 線程加入線程池等待CPU調度您机，時間很快，幾乎是立刻執(zhí)行
[thread1 start];
/** 方法二年局，創(chuàng)建好之后自動啟動 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];
/** 方法三际看，隱式創(chuàng)建，直接啟動 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];
- (void)doSomething1:(NSObject *)object {
// 傳遞過來的參數
NSLog(@"%@",object);
NSLog(@"doSomething1：%@",[NSThread currentThread]);
}
- (void)doSomething2:(NSObject *)object {
NSLog(@"%@",object);
NSLog(@"doSomething2：%@",[NSThread currentThread]);
}
- (void)doSomething3:(NSObject *)object {
NSLog(@"%@",object);
NSLog(@"doSomething3：%@",[NSThread currentThread]);
}
No.2：NSThread的類方法
- 返回當前線程
// 當前線程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);
// 如果number=1矢否，則表示在主線程仲闽，否則是子線程
打印結果：<NSThread: 0x608000261380>{number = 1, name = main}
- 阻塞休眠
//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定時間
[NSThread sleepUntilDate:[NSDate date]];
- 類方法補充
//退出線程
[NSThread exit];
//判斷當前線程是否為主線程
[NSThread isMainThread];
//判斷當前線程是否是多線程
[NSThread isMultiThreaded];
//主線程的對象
NSThread *mainThread = [NSThread mainThread];
No.3：NSThread的一些屬性
//線程是否在執(zhí)行
thread.isExecuting;
//線程是否被取消
thread.isCancelled;
//線程是否完成
thread.isFinished;
//是否是主線程
thread.isMainThread;
//線程的優(yōu)先級，取值范圍0.0到1.0僵朗，默認優(yōu)先級0.5赖欣，1.0表示最高優(yōu)先級，優(yōu)先級高验庙，CPU調度的頻率高
thread.threadPriority;
Demo：XM_Thread
六顶吮、GCD的理解與使用
No.1：GCD的特點
- GCD會自動利用更多的CPU內核
- GCD自動管理線程的生命周期（創(chuàng)建線程，調度任務粪薛，銷毀線程等）
- 程序員只需要告訴 GCD 想要如何執(zhí)行什么任務克锣，不需要編寫任何線程管理代碼
No.2：GCD的基本概念
任務（block）：任務就是將要在線程中執(zhí)行的代碼，將這段代碼用block封裝好崔列，然后將這個任務添加到指定的執(zhí)行方式（同步執(zhí)行和異步執(zhí)行），等待CPU從隊列中取出任務放到對應的線程中執(zhí)行挑社。
同步（sync）：一個接著一個，前一個沒有執(zhí)行完巡揍，后面不能執(zhí)行痛阻，不開線程。
異步（async）：開啟多個新線程腮敌，任務同一時間可以一起執(zhí)行阱当。異步是多線程的代名詞
隊列：裝載線程任務的隊形結構。(系統(tǒng)以先進先出的方式調度隊列中的任務執(zhí)行)糜工。在GCD中有兩種隊列：串行隊列和并發(fā)隊列弊添。
并發(fā)隊列：線程可以同時一起進行執(zhí)行。實際上是CPU在多條線程之間快速的切換捌木。（并發(fā)功能只有在異步（dispatch_async）函數下才有效）
串行隊列：線程只能依次有序的執(zhí)行油坝。
GCD總結：將任務(要在線程中執(zhí)行的操作block)添加到隊列(自己創(chuàng)建或使用全局并發(fā)隊列)，并且指定執(zhí)行任務的方式(異步dispatch_async刨裆，同步dispatch_sync)
No.3：隊列的創(chuàng)建方法
- 使用dispatch_queue_create來創(chuàng)建隊列對象澈圈，傳入兩個參數，第一個參數表示隊列的唯一標識符帆啃，可為空瞬女。第二個參數用來表示串行隊列（DISPATCH_QUEUE_SERIAL）或并發(fā)隊列（DISPATCH_QUEUE_CONCURRENT）。
// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 并發(fā)隊列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
GCD的隊列還有另外兩種：
- 主隊列：主隊列負責在主線程上調度任務努潘，如果在主線程上已經有任務正在執(zhí)行诽偷，主隊列會等到主線程空閑后再調度任務。通常是返回主線程更新UI的時候使用疯坤。dispatch_get_main_queue()
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 耗時操作放在這里
dispatch_async(dispatch_get_main_queue(), ^{
// 回到主線程進行UI操作
});
});
- 全局并發(fā)隊列：全局并發(fā)隊列是就是一個并發(fā)隊列报慕，是為了讓我們更方便的使用多線程。dispatch_get_global_queue(0, 0)
//全局并發(fā)隊列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局并發(fā)隊列的優(yōu)先級
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高優(yōu)先級
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默認（中）優(yōu)先級
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低優(yōu)先級
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后臺優(yōu)先級
//iOS8開始使用服務質量贴膘，現在獲取全局并發(fā)隊列時卖子，可以直接傳0
dispatch_get_global_queue(0, 0);
No.4：同步/異步/任務、創(chuàng)建方式
同步（sync）使用dispatch_sync來表示刑峡。
異步（async）使用dispatch_async洋闽。
任務就是將要在線程中執(zhí)行的代碼，將這段代碼用block封裝好突梦。
代碼如下：
// 同步執(zhí)行任務
dispatch_sync(dispatch_get_global_queue(0, 0), ^{
// 任務放在這個block里
NSLog(@"我是同步執(zhí)行的任務");
});
// 異步執(zhí)行任務
dispatch_async(dispatch_get_global_queue(0, 0), ^{
// 任務放在這個block里
NSLog(@"我是異步執(zhí)行的任務");
});
Demo：XM_Thread
No.5：GCD的使用
由于有多種隊列（串行/并發(fā)/主隊列）和兩種執(zhí)行方式（同步/異步）诫舅，所以他們之間可以有多種組合方式。
串行同步
串行異步
并發(fā)同步
并發(fā)異步
主隊列同步
主隊列異步
- 串行同步
執(zhí)行完一個任務宫患，再執(zhí)行下一個任務刊懈。不開啟新線程。
/** 串行同步 */
- (void)syncSerial {
NSLog(@"\n\n**************串行同步***************\n\n");
// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 同步執(zhí)行
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]);
}
});
}
NSLog(@"\n\n**************end***************\n\n");
輸入結果為順序執(zhí)行，都在主線程：
**************串行同步***************
2018-05-09 09:19:05.340175+0800 XM_Mediator_Example[52960:4954783] 串行同步1 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.340586+0800 XM_Mediator_Example[52960:4954783] 串行同步1 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341198+0800 XM_Mediator_Example[52960:4954783] 串行同步1 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341395+0800 XM_Mediator_Example[52960:4954783] 串行同步2 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341571+0800 XM_Mediator_Example[52960:4954783] 串行同步2 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341727+0800 XM_Mediator_Example[52960:4954783] 串行同步2 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341952+0800 XM_Mediator_Example[52960:4954783] 串行同步3 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.342184+0800 XM_Mediator_Example[52960:4954783] 串行同步3 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.342395+0800 XM_Mediator_Example[52960:4954783] 串行同步3 <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.342795+0800 XM_Mediator_Example[52960:4954783]
**************end***************
- 串行異步
開啟新線程虚汛，但因為任務是串行的匾浪，所以還是按順序執(zhí)行任務。
/** 串行異步 */
- (void)asyncSerial {
NSLog(@"\n\n**************串行異步***************\n\n");
// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 同步執(zhí)行
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]);
}
});
NSLog(@"\n\n**************end***************\n\n");
}
輸入結果為順序執(zhí)行卷哩，有不同線程：
**************串行異步***************
2018-05-09 09:20:46.996620+0800 XM_Mediator_Example[53058:4965801]
**************end***************
2018-05-09 09:20:46.996721+0800 XM_Mediator_Example[53058:4966256] 串行異步1 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.996938+0800 XM_Mediator_Example[53058:4966256] 串行異步1 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997423+0800 XM_Mediator_Example[53058:4966256] 串行異步1 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997598+0800 XM_Mediator_Example[53058:4966256] 串行異步2 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997825+0800 XM_Mediator_Example[53058:4966256] 串行異步2 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997976+0800 XM_Mediator_Example[53058:4966256] 串行異步2 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.998212+0800 XM_Mediator_Example[53058:4966256] 串行異步3 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.998433+0800 XM_Mediator_Example[53058:4966256] 串行異步3 <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.998721+0800 XM_Mediator_Example[53058:4966256] 串行異步3 <NSThread: 0x600000678380>{number = 3, name = (null)}
- 并發(fā)同步
因為是同步的蛋辈，所以執(zhí)行完一個任務，再執(zhí)行下一個任務将谊。不會開啟新線程冷溶。
/** 并發(fā)同步 */
- (void)syncConcurrent {
NSLog(@"\n\n**************并發(fā)同步***************\n\n");
// 并發(fā)隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 同步執(zhí)行
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"并發(fā)同步1 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"并發(fā)同步2 %@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"并發(fā)同步3 %@",[NSThread currentThread]);
}
});
NSLog(@"\n\n**************end***************\n\n");
}
輸入結果為順序執(zhí)行，都在主線程：
**************并發(fā)同步***************
2018-05-09 09:22:20.661175+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步1 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661465+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步1 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661625+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步1 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661767+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步2 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661890+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步2 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.662199+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步2 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.662749+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步3 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.663246+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步3 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.663565+0800 XM_Mediator_Example[53142:4976084] 并發(fā)同步3 <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.663781+0800 XM_Mediator_Example[53142:4976084]
**************end***************
- 并發(fā)異步
任務交替執(zhí)行尊浓，開啟多線程逞频。
/** 并發(fā)異步 */
- (void)asyncConcurrent {
NSLog(@"\n\n**************并發(fā)異步***************\n\n");
// 并發(fā)隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 同步執(zhí)行
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"并發(fā)異步1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"并發(fā)異步2 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"并發(fā)異步3 %@",[NSThread currentThread]);
}
});
NSLog(@"\n\n**************end***************\n\n");
}
輸入結果為無序執(zhí)行，有多條線程：
**************并發(fā)異步***************
2018-05-09 09:23:48.985161+0800 XM_Mediator_Example[53236:4985467]
**************end***************
2018-05-09 09:23:48.985313+0800 XM_Mediator_Example[53236:4985948] 并發(fā)異步3 <NSThread: 0x60000066b140>{number = 4, name = (null)}
2018-05-09 09:23:48.985324+0800 XM_Mediator_Example[53236:4985949] 并發(fā)異步2 <NSThread: 0x60000066bac0>{number = 5, name = (null)}
2018-05-09 09:23:48.985346+0800 XM_Mediator_Example[53236:4985950] 并發(fā)異步1 <NSThread: 0x604000665b80>{number = 3, name = (null)}
2018-05-09 09:23:48.986612+0800 XM_Mediator_Example[53236:4985948] 并發(fā)異步3 <NSThread: 0x60000066b140>{number = 4, name = (null)}
2018-05-09 09:23:48.986821+0800 XM_Mediator_Example[53236:4985950] 并發(fā)異步1 <NSThread: 0x604000665b80>{number = 3, name = (null)}
2018-05-09 09:23:48.986822+0800 XM_Mediator_Example[53236:4985949] 并發(fā)異步2 <NSThread: 0x60000066bac0>{number = 5, name = (null)}
2018-05-09 09:23:48.986972+0800 XM_Mediator_Example[53236:4985950] 并發(fā)異步1 <NSThread: 0x604000665b80>{number = 3, name = (null)}
2018-05-09 09:23:48.987191+0800 XM_Mediator_Example[53236:4985948] 并發(fā)異步3 <NSThread: 0x60000066b140>{number = 4, name = (null)}
2018-05-09 09:23:48.988051+0800 XM_Mediator_Example[53236:4985949] 并發(fā)異步2 <NSThread: 0x60000066bac0>{number = 5, name = (null)}
- 主隊列同步
如果在主線程中運用這種方式栋齿，則會發(fā)生死鎖苗胀，程序崩潰。
/** 主隊列同步 */
- (void)syncMain {
NSLog(@"\n\n**************主隊列同步褒颈，放到主線程會死鎖***************\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]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"主隊列同步3 %@",[NSThread currentThread]);
}
});
}
主隊列同步造成死鎖的原因：
如果在主線程中運用主隊列同步柒巫，也就是把任務放到了主線程的隊列中励堡。
而同步對于任務是立刻執(zhí)行的谷丸，那么當把第一個任務放進主隊列時，它就會立馬執(zhí)行应结。
可是主線程現在正在處理syncMain方法刨疼，任務需要等syncMain執(zhí)行完才能執(zhí)行。
syncMain執(zhí)行到第一個任務的時候鹅龄，又要等第一個任務執(zhí)行完才能往下執(zhí)行第二個和第三個任務揩慕。
這樣syncMain方法和第一個任務就開始了互相等待，形成了死鎖扮休。
- 主隊列異步
在主線程中任務按順序執(zhí)行迎卤。
/** 主隊列異步 */
- (void)asyncMain {
NSLog(@"\n\n**************主隊列異步***************\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]);
}
});
}
輸入結果為在主線程中按順序執(zhí)行：
主隊列異步1 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步1 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步1 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3 <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3 <NSThread: 0x60000007c500>{number = 1, name = main}
- GCD線程之間的通訊
開發(fā)中需要在主線程上進行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柵欄
當任務需要異步進行，但是這些任務需要分成兩組來執(zhí)行叔壤，第一組完成之后才能進行第二組的操作瞎饲。這時候就用了到GCD的柵欄方法dispatch_barrier_async。
- (IBAction)barrierGCD:(id)sender {
// 并發(fā)隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);
// 異步執(zhí)行
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：并發(fā)異步1 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：并發(fā)異步2 %@",[NSThread currentThread]);
}
});
dispatch_barrier_async(queue, ^{
NSLog(@"------------barrier------------%@", [NSThread currentThread]);
NSLog(@"******* 并發(fā)異步執(zhí)行炼绘，但是34一定在12后面 *********");
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：并發(fā)異步3 %@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 3; i++) {
NSLog(@"柵欄：并發(fā)異步4 %@",[NSThread currentThread]);
}
});
}
上面代碼的打印結果如下企软，開啟了多條線程，所有任務都是并發(fā)異步進行饭望。但是第一組完成之后仗哨，才會進行第二組的操作。
柵欄：并發(fā)異步1 <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發(fā)異步2 <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發(fā)異步1 <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發(fā)異步2 <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發(fā)異步1 <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發(fā)異步2 <NSThread: 0x60000026e480>{number = 6, name = (null)}
------------barrier------------<NSThread: 0x60000026e480>{number = 6, name = (null)}
******* 并發(fā)異步執(zhí)行铅辞，但是34一定在12后面 *********
柵欄：并發(fā)異步4 <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發(fā)異步3 <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發(fā)異步4 <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發(fā)異步3 <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發(fā)異步4 <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發(fā)異步3 <NSThread: 0x60000026e480>{number = 6, name = (null)}
- GCD延時執(zhí)行
當需要等待一會再執(zhí)行一段代碼時厌漂，就可以用到這個方法了：dispatch_after。
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 5秒后異步執(zhí)行
NSLog(@"我已經等待了5秒斟珊！");
});
- GCD實現代碼只執(zhí)行一次
使用dispatch_once能保證某段代碼在程序運行過程中只被執(zhí)行1次苇倡。可以用來設計單例囤踩。
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"程序運行過程中我只執(zhí)行了一次旨椒！");
});
- GCD快速迭代
GCD有一個快速迭代的方法dispatch_apply，dispatch_apply可以同時遍歷多個數字堵漱。
- (IBAction)applyGCD:(id)sender {
NSLog(@"\n\n************** GCD快速迭代 ***************\n\n");
// 并發(fā)隊列
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======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：1======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：2======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：3======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：4======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：5======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：6======<NSThread: 0x60000007c500>{number = 1, name = main}
- GCD隊列組
異步執(zhí)行幾個耗時操作综慎，當這幾個操作都完成之后再回到主線程進行操作，就可以用到隊列組了勤庐。
隊列組有下面幾個特點：
所有的任務會并發(fā)的執(zhí)行(不按序)示惊。
所有的異步函數都添加到隊列中，然后再納入隊列組的監(jiān)聽范圍愉镰。
使用dispatch_group_notify函數米罚，來監(jiān)聽上面的任務是否完成，如果完成, 就會調用這個方法丈探。
隊列組示例代碼：
- (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_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"隊列組：前面的耗時操作都完成了碗降，回到主線程進行相關操作");
});
}
打印結果如下：
隊列組：有一個耗時操作完成隘竭！
隊列組：有一個耗時操作完成！
隊列組：前面的耗時操作都完成了遗锣，回到主線程進行相關操作
6.6 GCD 信號量：dispatch_semaphore
GCD 中的信號量是指Dispatch Semaphore货裹，是持有計數的信號。類似于過高速路收費站的欄桿精偿』≡玻可以通過時赋兵，打開欄桿，不可以通過時搔预，關閉欄桿霹期。在Dispatch Semaphore中，使用計數來完成這個功能拯田，計數為0時等待历造，不可通過。計數為1或大于1時船庇，計數減1且不等待吭产，可通過。
Dispatch Semaphore提供了三個函數鸭轮。
dispatch_semaphore_create：創(chuàng)建一個Semaphore并初始化信號的總量
dispatch_semaphore_signal：發(fā)送一個信號臣淤，讓信號總量加1
dispatch_semaphore_wait：可以使總信號量減1，當信號總量為0時就會一直等待（阻塞所在線程）窃爷，否則就可以正常執(zhí)行邑蒋。
注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續(xù)執(zhí)行按厘，然后使用信號量医吊。
Dispatch Semaphore 在實際開發(fā)中主要用于：
保持線程同步，將異步執(zhí)行任務轉換為同步執(zhí)行任務
保證線程安全逮京，為線程加鎖
6.6.1 Dispatch Semaphore 線程同步
我們在開發(fā)中卿堂，會遇到這樣的需求：異步執(zhí)行耗時任務，并使用異步執(zhí)行的結果進行一些額外的操作造虏。換句話說御吞，相當于，將將異步執(zhí)行任務轉換為同步執(zhí)行任務漓藕。比如說：AFNetworking 中 AFURLSessionManager.m 里面的tasksForKeyPath:方法。通過引入信號量的方式挟裂，等待異步執(zhí)行任務結果享钞，獲取到 tasks，然后再返回該 tasks诀蓉。
- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
__block NSArray *tasks = nil;
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
[self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
tasks = dataTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
tasks = uploadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
tasks = downloadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
}
dispatch_semaphore_signal(semaphore);
}];
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
return tasks;
}
下面栗竖，我們來利用 Dispatch Semaphore 實現線程同步，將異步執(zhí)行任務轉換為同步執(zhí)行任務渠啤。
+ (void)semaphoreSync
{
NSLog(@"currentThread---%@",[NSThread currentThread]);// 打印當前線程NSLog(@"semaphore---begin");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block int number =0;
dispatch_async(queue, ^{// 追加任務1
[NSThread sleepForTimeInterval:2];
// 模擬耗時操作
NSLog(@"1---%@",[NSThread currentThread]);
// 打印當前線程number =100;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"semaphore---end,number = %zd",number);
}
image.png
6.6.2 Dispatch Semaphore 線程安全和線程同步（為線程加鎖）
線程安全：如果你的代碼所在的進程中有多個線程在同時運行狐肢，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的沥曹，而且其他的變量的值也和預期的是一樣的份名，就是線程安全的碟联。
若每個線程中對全局變量、靜態(tài)變量只有讀操作僵腺，而無寫操作鲤孵，一般來說，這個全局變量是線程安全的辰如；若有多個線程同時執(zhí)行寫操作（更改變量）普监，一般都需要考慮線程同步，否則的話就可能影響線程安全琉兜。
線程同步：可理解為線程 A 和 線程 B 一塊配合凯正，A 執(zhí)行到一定程度時要依靠線程 B 的某個結果，于是停下來豌蟋，示意 B 運行漆际；B 依言執(zhí)行，再將結果給 A夺饲；A 再繼續(xù)操作奸汇。
舉個簡單例子就是：兩個人在一起聊天。兩個人不能同時說話往声，避免聽不清(操作沖突)擂找。等一個人說完(一個線程結束操作)，另一個再說(另一個線程再開始操作)浩销。
6.6.2.2 線程安全（使用 semaphore 加鎖）買票
+ (void)initTicketStatusSave {
NSLog(@"currentThread---%@",[NSThread currentThread]);// 打印當前線程
NSLog(@"semaphore---begin");
semaphoreLock = dispatch_semaphore_create(1);
ticketSurplusCount =50;// queue1 代表北京火車票售賣窗口
dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_CONCURRENT);// queue2 代表上汗嵯眩火車票售賣窗口
dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_CONCURRENT);
__weak typeof(self) weakSelf =self;
dispatch_async(queue1, ^{
[weakSelf saleTicketSafe];
});
dispatch_async(queue2, ^{
[weakSelf saleTicketSafe];
});
NSLog(@"initTicketStatusSave---end");
}
+ (void)saleTicketSafe {
while(1) {// 相當于加鎖
dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
if(ticketSurplusCount >0) {//如果還有票，繼續(xù)售賣
ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩余票數：%d 窗口：%@",ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}else{//如果已賣完慢洋，關閉售票窗口
NSLog(@"所有火車票均已售完");
// 相當于解鎖
dispatch_semaphore_signal(semaphoreLock);
break;
}
// 相當于解鎖
dispatch_semaphore_signal(semaphoreLock);
}
}
至此塘雳，GCD的相關內容敘述完畢。下面讓我們繼續(xù)學習NSOperation普筹。
Demo：XM_Thread
七败明、NSOperation的理解與使用
No.1：NSOperation簡介
NSOperation是基于GCD之上的更高一層封裝，NSOperation需要配合NSOperationQueue來實現多線程太防。
NSOperation實現多線程的步驟如下：
1. 創(chuàng)建任務：先將需要執(zhí)行的操作封裝到NSOperation對象中妻顶。
2. 創(chuàng)建隊列：創(chuàng)建NSOperationQueue。
3. 將任務加入到隊列中：將NSOperation對象添加到NSOperationQueue中蜒车。
需要注意的是讳嘱，NSOperation是個抽象類，實際運用時中需要使用它的子類酿愧，有三種方式：
- 使用子類NSInvocationOperation
- 使用子類NSBlockOperation
- 定義繼承自NSOperation的子類沥潭，通過實現內部相應的方法來封裝任務。
No.2：NSOperation的三種創(chuàng)建方式
- NSInvocationOperation的使用
創(chuàng)建NSInvocationOperation對象并關聯方法嬉挡，之后start钝鸽。
- (void)testNSInvocationOperation {
// 創(chuàng)建NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
// 開始執(zhí)行操作
[invocationOperation start];
}
- (void)invocationOperation {
NSLog(@"NSInvocationOperation包含的任務汇恤，沒有加入隊列========%@", [NSThread currentThread]);
}
打印結果如下，得到結論：程序在主線程執(zhí)行寞埠，沒有開啟新線程屁置。
這是因為NSOperation多線程的使用需要配合隊列NSOperationQueue，后面會講到NSOperationQueue的使用仁连。
NSInvocationOperation包含的任務蓝角，沒有加入隊列========<NSThread: 0x6000000783c0>{number = 1, name = main}
- NSBlockOperation的使用
把任務放到NSBlockOperation的block中，然后start饭冬。
- (void)testNSBlockOperation {
// 把任務放到block中
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation包含的任務使鹅，沒有加入隊列========%@", [NSThread currentThread]);
}];
[blockOperation start];
}
執(zhí)行結果如下，可以看出：主線程執(zhí)行昌抠，沒有開啟新線程患朱。
同樣的，NSBlockOperation可以配合隊列NSOperationQueue來實現多線程炊苫。
NSBlockOperation包含的任務裁厅，沒有加入隊列========<NSThread: 0x6000000783c0>{number = 1, name = main}
但是NSBlockOperation有一個方法addExecutionBlock:，通過這個方法可以讓NSBlockOperation實現多線程侨艾。
- (void)testNSBlockOperationExecution {
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"NSBlockOperation運用addExecutionBlock主任務========%@", [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];
}
執(zhí)行結果如下执虹，可以看出，NSBlockOperation創(chuàng)建時block中的任務是在主線程執(zhí)行唠梨，而運用addExecutionBlock加入的任務是在子線程執(zhí)行的袋励。
NSBlockOperation運用addExecutionBlock========<NSThread: 0x60800006ccc0>{number = 1, name = main}
addExecutionBlock方法添加任務1========<NSThread: 0x60800007ec00>{number = 3, name = (null)}
addExecutionBlock方法添加任務3========<NSThread: 0x6000002636c0>{number = 5, name = (null)}
addExecutionBlock方法添加任務2========<NSThread: 0x60800007e800>{number = 4, name = (null)}
- 運用繼承自NSOperation的子類
首先我們定義一個繼承自NSOperation的類，然后重寫它的main方法当叭，之后就可以使用這個子類來進行相關的操作了茬故。
/*******************"WHOperation.h"*************************/
#import <Foundation/Foundation.h>
@interface WHOperation : NSOperation
@end
/*******************"WHOperation.m"*************************/
#import "WHOperation.h"
@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];
}
運行結果如下，依然是在主線程執(zhí)行蚁鳖。
SOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
所以磺芭，NSOperation是需要配合隊列NSOperationQueue來實現多線程的。下面就來說一下隊列NSOperationQueue才睹。
No.3：隊列NSOperationQueue
NSOperationQueue只有兩種隊列：主隊列徘跪、其他隊列。其他隊列包含了串行和并發(fā)琅攘。
主隊列的創(chuàng)建如下，主隊列上的任務是在主線程執(zhí)行的松邪。
NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];
其他隊列（非主隊列）的創(chuàng)建如下坞琴，加入到‘非隊列’中的任務默認就是并發(fā)，開啟多線程逗抑。
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
注意：
- 非主隊列（其他隊列）可以實現串行或并行剧辐。
- 隊列NSOperationQueue有一個參數叫做最大并發(fā)數：maxConcurrentOperationCount寒亥。
- maxConcurrentOperationCount默認為-1，直接并發(fā)執(zhí)行荧关，所以加入到‘非隊列’中的任務默認就是并發(fā)溉奕，開啟多線程。
- 當maxConcurrentOperationCount為1時忍啤，則表示不開線程加勤，也就是串行。
- 當maxConcurrentOperationCount大于1時同波，進行并發(fā)執(zhí)行鳄梅。
- 系統(tǒng)對最大并發(fā)數有一個限制，所以即使程序員把maxConcurrentOperationCount設置的很大未檩，系統(tǒng)也會自動調整戴尸。所以把最大并發(fā)數設置的很大是沒有意義的。
No.4：NSOperation + NSOperationQueue
把任務加入隊列冤狡，這才是NSOperation的常規(guī)使用方式孙蒙。
- addOperation添加任務到隊列
先創(chuàng)建好任務，然后運用- (void)addOperation:(NSOperation *)op 方法來吧任務添加到隊列中悲雳，示例代碼如下：
- (void)testOperationQueue {
// 創(chuàng)建隊列挎峦，默認并發(fā)
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 創(chuàng)建操作，NSInvocationOperation
NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
// 創(chuàng)建操作怜奖，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]);
}
運行結果如下浑测，可以看出，任務都是在子線程執(zhí)行的歪玲，開啟了新線程迁央！
invocationOperation===addOperation把任務添加到隊列====<NSThread: 0x60800026ed00>{number = 4, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
- addOperationWithBlock添加任務到隊列
這是一個更方便的把任務添加到隊列的方法，直接把任務寫在block中滥崩，添加到任務中岖圈。
- (void)testAddOperationWithBlock {
// 創(chuàng)建隊列，默認并發(fā)
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 添加操作到隊列
[queue addOperationWithBlock:^{
for (int i = 0; i < 3; i++) {
NSLog(@"addOperationWithBlock把任務添加到隊列======%@", [NSThread currentThread]);
}
}];
}
運行結果如下钙皮，任務確實是在子線程中執(zhí)行蜂科。
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
- 運用最大并發(fā)數實現串行
上面已經說過，可以運用隊列的屬性maxConcurrentOperationCount（最大并發(fā)數）來實現串行短条，值需要把它設置為1就可以了导匣，下面我們通過代碼驗證一下。
- (void)testMaxConcurrentOperationCount {
// 創(chuàng)建隊列茸时，默認并發(fā)
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 最大并發(fā)數為1贡定，串行
queue.maxConcurrentOperationCount = 1;
// 最大并發(fā)數為2，并發(fā)
// queue.maxConcurrentOperationCount = 2;
// 添加操作到隊列
[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]);
}
}];
}
運行結果如下可都，當最大并發(fā)數為1的時候缓待，雖然開啟了線程蚓耽，但是任務是順序執(zhí)行的，所以實現了串行旋炒。
你可以嘗試把上面的最大并發(fā)數變?yōu)?步悠，會發(fā)現任務就變成了并發(fā)執(zhí)行。
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
No.5：NSOperation的其他操作
- 取消隊列NSOperationQueue的所有操作瘫镇，NSOperationQueue對象方法
- (void)cancelAllOperations
- 取消NSOperation的某個操作鼎兽，NSOperation對象方法
- (void)cancel
- 使隊列暫停或繼續(xù)
// 暫停隊列
[queue setSuspended:YES];
- 判斷隊列是否暫停
- (BOOL)isSuspended
暫停和取消不是立刻取消當前操作汇四，而是等當前的操作執(zhí)行完之后不再進行新的操作接奈。
No.6：NSOperation的操作依賴
NSOperation有一個非常好用的方法，就是操作依賴通孽⌒蚧拢可以從字面意思理解：某一個操作（operation2）依賴于另一個操作（operation1）概龄，只有當operation1執(zhí)行完畢萧吠，才能執(zhí)行operation2禀忆，這時蒋情，就是操作依賴大顯身手的時候了。
- (void)testAddDependency {
// 并發(fā)隊列
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執(zhí)行完畢如贷，operation2才會執(zhí)行****");
for (int i = 0; i < 3; i++) {
NSLog(@"operation2======%@", [NSThread currentThread]);
}
}];
// 使操作2依賴于操作1
[operation2 addDependency:operation1];
// 把操作加入隊列
[queue addOperation:operation1];
[queue addOperation:operation2];
}
運行結果如下漾根，操作2總是在操作1之后執(zhí)行厚宰，成功驗證了上面的說法腌巾。
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
****operation2依賴于operation1，只有當operation1執(zhí)行完畢铲觉，operation2才會執(zhí)行****
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
