筆記-iOS 多線程：『NSOperation、NSOperationQueue』詳盡總結
NSOperation、NSOperationQueue 簡介
轉載：行走少年郎數組
NSOperation、NSOperationQueue 是基於 GCD 更高一層的封裝，因此也有相似的任務（操做） 和隊列（操做隊列） 的概念安全
-
操做（Operation）：bash
- 執行操做的意思，換句話說就是你在線程中執行的那段代碼。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，咱們使用 NSOperation 子類 NSInvocationOperation、NSBlockOperation，或者自定義子類來封裝操做。
-
操做隊列（Operation Queues）：多線程
- 這裏的隊列指操做隊列，即用來存放操做的隊列。不一樣於 GCD 中的調度隊列 FIFO（先進先出）的原則。NSOperationQueue 對於添加到隊列中的操做，首先進入準備就緒的狀態（就緒狀態取決於操做之間的依賴關係），而後進入就緒狀態的操做的開始執行順序（非結束執行順序）由操做之間相對的優先級決定（優先級是操做對象自身的屬性）。
- 操做隊列經過設置最大併發操做數（maxConcurrentOperationCount）來控制併發、串行。
- NSOperationQueue 爲咱們提供了兩種不一樣類型的隊列：主隊列和自定義隊列。主隊列運行在主線程之上，而自定義隊列在後臺執行。
NSOperation、NSOperationQueue使用步驟
NSOperation須要配合NSOperationQueue來實現多線程。由於默認狀況下，NSOperation單獨使用時，系統同步執行操做，配合NSOperationQueue咱們能更好的實現異步執行。併發
NSOperation實現多線程通常分三步：異步
- 建立操做：先將須要執行的操做封裝到一個
NSOperation對象中。 - 建立隊列：建立
NSOperationQueue對象。 - 將操做加入到隊列中：將
NSOperation對象添加到NSOperationQueue對象中。
以後，系統就會自動將NSOperationQueue中的NSOperation取出來，在新線程中執行操做。ui
NSOperation 和NSOperationQueue基本使用
建立操做
NSOperation是個抽象類，不能來封裝操做。咱們只有使用它的子類來封裝操做。atom
- 使用子類
NSInvocationOperation - 使用子類
NSBlockOperation - 自定義繼承
NSOperation的子類，經過實現內部相應的方法來封裝操做。
子類NSInvocationOperation
- (void)demo {
NSInvocationOperation *op = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(handleInvocation:) object:@"zuobian"];
// 注意: 若是該任務已經添加到隊列,你再手動調回出錯
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
[queue addOperation:op];
// 若是就是在主線程中調用建議使用下面的方法執行
// [[NSOperationQueue mainQueue] addOperation:op]; // 推薦使用
// 手動調起操做,默認在當前線程
// [op start]; // 不推薦使用
}
複製代碼
知識點：spa
- 在沒有使用
NSOperationQueue、在主線程中單獨使用使用子類NSInvocationOperation執行一個操做的狀況下，操做是在當前線程執行的，並無開啓新線程。 - 若是在其餘線程中執行操做，則打印結果爲其餘線程。
子類NSBlockOperation
- (void)demo {
//1:建立blockOperation
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
NSLog(@"%@",[NSThread currentThread]);
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印當前線程
}
}];
[op addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印當前線程
}
}];
//1.1 設置監聽
op.completionBlock = ^{
NSLog(@"%@",[NSThread currentThread]);
NSLog(@"完成了!!!");
};
//2:建立隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//3:添加到隊列
[queue addOperation:op];
// 異步致使這裏先走
NSLog(@"--------------- 完成了!!!"); // 最早輸出
}
複製代碼
NSBlockOperation 還提供了一個方法 addExecutionBlock:，經過 addExecutionBlock: 就能夠爲 NSBlockOperation 添加額外的操做。這些操做（包括 blockOperationWithBlock 中的操做）能夠在不一樣的線程中同時（併發）執行。只有當全部相關的操做已經完成執行時，才視爲完成。 若是添加的操做多的話，blockOperationWithBlock: 中的操做也可能會在其餘線程（非當前線程）中執行，這是由系統決定的，並非說添加到 blockOperationWithBlock: 中的操做必定會在當前線程中執行。（可使用 addExecutionBlock: 多添加幾個操做試試）。線程
知識點：
- 在沒有使用
NSOperationQueue、在主線程中單獨使用NSBlockOperation執行一個操做的狀況下，操做是在當前線程執行的，並無開啓新線程。 - 通常狀況下，若是一個 NSBlockOperation 對象封裝了多個操做。NSBlockOperation 是否開啓新線程，取決於操做的個數。若是添加的操做的個數多，就會自動開啓新線程。固然開啓的線程數是由系統來決定的。
使用自定義繼承自NSOperation的子類
咱們可使用自定義繼承自 NSOperation 的子類。能夠經過重寫 main 或者 start 方法 來定義本身的 NSOperation 對象。重寫main方法比較簡單，咱們不須要管理操做的狀態屬性 isExecuting 和 isFinished。當 main 執行完返回的時候，這個操做就結束了。
// .h 文件
#import <Foundation/Foundation.h>
@interface ZBOperation : NSOperation
@end
// .m 文件
#import "ZBOperation.h"
@implementation ZBOperation
- (void)main {
if (!self.isCancelled) {
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2];
NSLog(@"1---%@", [NSThread currentThread]);
}
}
}
@end
複製代碼
使用的時候導入頭文件便可
/**
* 使用自定義繼承自 NSOperation 的子類
*/
- (void)useCustomOperation {
// 1.建立 ZBOperation 對象
ZBOperation *op = [[ZBOperation alloc] init];
// 2.調用 start 方法開始執行操做
[op start];
}
複製代碼
在沒有使用 NSOperationQueue、在主線程單獨使用自定義繼承自 NSOperation 的子類的狀況下，是在主線程執行操做，並無開啓新線程。
建立隊列
NSOperationQueue 一共有兩種隊列：主隊列、自定義隊列。其中自定義隊列同時包含了串行、併發功能。下邊是主隊列、自定義隊列的基本建立方法和特色。
- 主隊列
- 凡是添加到主隊列中的操做，都會放到主線程中執行（注：不包括操做使用
addExecutionBlock:添加的額外操做，額外操做可能在其餘線程執行）。
- 凡是添加到主隊列中的操做，都會放到主線程中執行（注：不包括操做使用
// 主隊列獲取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];
複製代碼
- 自定義隊列（非主隊列）
- 添加到這種隊列中的操做，就會自動放到子線程中執行。
- 同時包含了：串行、併發功能。
// 自定義隊列建立方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
複製代碼
將操做加入到隊列中
上邊咱們說到 NSOperation 須要配合 NSOperationQueue 來實現多線程。
那麼咱們須要將建立好的操做加入到隊列中去。總共有兩種方法：
- (void)addOperation:(NSOperation *)op;- 須要先建立操做，再將建立好的操做加入到建立好的隊列中去。
/**
* 使用 addOperation: 將操做加入到操做隊列中
*/
- (void)addOperationToQueue {
// 1.建立隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.建立操做
// 使用 NSInvocationOperation 建立操做1
NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
// 使用 NSInvocationOperation 建立操做2
NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];
// 使用 NSBlockOperation 建立操做3
NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"3---%@", [NSThread currentThread]); // 打印當前線程
}
}];
[op3 addExecutionBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"4---%@", [NSThread currentThread]); // 打印當前線程
}
}];
// 3.使用 addOperation: 添加全部操做到隊列中
[queue addOperation:op1]; // [op1 start]
[queue addOperation:op2]; // [op2 start]
[queue addOperation:op3]; // [op3 start]
}
複製代碼
使用 NSOperation 子類建立操做，並使用 addOperation: 將操做加入到操做隊列後可以開啓新線程，進行併發執行。
- (void)addOperationWithBlock:(void (^)(void))block;- 無需先建立操做，在
block中添加操做，直接將包含操做的block加入到隊列中。
- 無需先建立操做，在
/**
* 使用 addOperationWithBlock: 將操做加入到操做隊列中
*/
- (void)addOperationWithBlockToQueue {
// 1.建立隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.使用 addOperationWithBlock: 添加操做到隊列中
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印當前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印當前線程
}
}];
[queue addOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"3---%@", [NSThread currentThread]); // 打印當前線程
}
}];
}
複製代碼
使用 addOperationWithBlock: 將操做加入到操做隊列後可以開啓新線程，進行併發執行。
NSOperationQueue 控制串行執行、併發執行
以前咱們說過，NSOperationQueue 建立的自定義隊列同時具備串行、併發功能，上邊咱們演示了併發功能，那麼他的串行功能是如何實現的？
這裏有個關鍵屬性 maxConcurrentOperationCount，叫作最大併發操做數。用來控制一個特定隊列中能夠有多少個操做同時參與併發執行。
注意：這裏
maxConcurrentOperationCount控制的不是併發線程的數量，而是一個隊列中同時能併發執行的最大操做數。並且一個操做也並不是只能在一個線程中運行。
- 最大併發操做數：
maxConcurrentOperationCountmaxConcurrentOperationCount默認狀況下爲-1，表示不進行限制，可進行併發執行。maxConcurrentOperationCount爲1時，隊列爲串行隊列。只能串行執行。maxConcurrentOperationCount大於1時，隊列爲併發隊列。操做併發執行，固然這個值不該超過系統限制，即便本身設置一個很大的值，系統也會自動調整爲 min{本身設定的值，系統設定的默認最大值}。
當最大併發操做數爲1時，操做是按順序串行執行的，而且一個操做完成以後，下一個操做纔開始執行。當最大操做併發數爲2時，操做是併發執行的，能夠同時執行兩個操做。而開啓線程數量是由系統決定的，不須要咱們來管理
NSOperation 操做依賴
NSOperation、NSOperationQueue最吸引人的地方是它能添加操做之間的依賴關係。經過操做依賴，咱們能夠很方便的控制操做之間的執行前後順序。NSOperation 提供了3個接口供咱們管理和查看依賴。
- (void)addDependency:(NSOperation *)op;添加依賴，使當前操做依賴於操做op的完成。- (void)removeDependency:(NSOperation *)op;移除依賴，取消當前操做對操做op的依賴。@property (readonly, copy) NSArray<NSOperation *> *dependencies;在當前操做開始執行以前完成執行的全部操做對象數組。
/**
* 操做依賴
* 使用方法：addDependency:
*/
- (void)addDependency {
// 1.建立隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 2.建立操做
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印當前線程
}
}];
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印當前線程
}
}];
// 3.添加依賴
[op2 addDependency:op1]; // 讓op2 依賴於 op1，則先執行op1，在執行op2
// 4.添加操做到隊列中
[queue addOperation:op1];
[queue addOperation:op2];
}
複製代碼
經過添加操做依賴，不管運行幾回，其結果都是 op1 先執行，op2 後執行。
NSOperation 優先級
NSOperation 提供了queuePriority（優先級）屬性，queuePriority屬性適用於同一操做隊列中的操做，不適用於不一樣操做隊列中的操做。默認狀況下，全部新建立的操做對象優先級都是NSOperationQueuePriorityNormal。可是咱們能夠經過setQueuePriority:方法來改變當前操做在同一隊列中的執行優先級。
// 優先級的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
NSOperationQueuePriorityVeryLow = -8L,
NSOperationQueuePriorityLow = -4L,
NSOperationQueuePriorityNormal = 0,
NSOperationQueuePriorityHigh = 4,
NSOperationQueuePriorityVeryHigh = 8
};
複製代碼
上邊咱們說過：對於添加到隊列中的操做，首先進入準備就緒的狀態（就緒狀態取決於操做之間的依賴關係），而後進入就緒狀態的操做的開始執行順序（非結束執行順序）由操做之間相對的優先級決定（優先級是操做對象自身的屬性）。
- 當一個操做的全部依賴都已經完成時，操做對象一般會進入準備就緒狀態，等待執行。
舉個例子，如今有4個優先級都是 NSOperationQueuePriorityNormal（默認級別）的操做：op1，op2，op3，op4。其中 op3 依賴於 op2，op2 依賴於 op1，即 op3 -> op2 -> op1。如今將這4個操做添加到隊列中併發執行。
- 由於 op1 和 op4 都沒有須要依賴的操做，因此在 op1，op4 執行以前，就是處於準備就緒狀態的操做。
- 而 op3 和 op2 都有依賴的操做（op3 依賴於 op2，op2 依賴於 op1），因此 op3 和 op2 都不是準備就緒狀態下的操做。
理解了進入就緒狀態的操做，那麼咱們就理解了queuePriority 屬性的做用對象。
queuePriority屬性決定了進入準備就緒狀態下的操做之間的開始執行順序。而且，優先級不能取代依賴關係。- 若是一個隊列中既包含高優先級操做，又包含低優先級操做，而且兩個操做都已經準備就緒，那麼隊列先執行高優先級操做。好比上例中，若是 op1 和 op4 是不一樣優先級的操做，那麼就會先執行優先級高的操做。
- 若是，一個隊列中既包含了準備就緒狀態的操做，又包含了未準備就緒的操做，未準備就緒的操做優先級比準備就緒的操做優先級高。那麼，雖然準備就緒的操做優先級低，也會優先執行。優先級不能取代依賴關係。若是要控制操做間的啓動順序，則必須使用依賴關係。
NSOperation、NSOperationQueue 線程間的通訊
在 iOS 開發過程當中，咱們通常在主線程裏邊進行 UI 刷新，例如：點擊、滾動、拖拽等事件。咱們一般把一些耗時的操做放在其餘線程，好比說圖片下載、文件上傳等耗時操做。而當咱們有時候在其餘線程完成了耗時操做時，須要回到主線程，那麼就用到了線程之間的通信。
/**
* 線程間通訊
*/
- (void)communication {
// 1.建立隊列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];
// 2.添加操做
[queue addOperationWithBlock:^{
// 異步進行耗時操做
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"1---%@", [NSThread currentThread]); // 打印當前線程
}
// 回到主線程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
// 進行一些 UI 刷新等操做
for (int i = 0; i < 2; i++) {
[NSThread sleepForTimeInterval:2]; // 模擬耗時操做
NSLog(@"2---%@", [NSThread currentThread]); // 打印當前線程
}
}];
}];
}
複製代碼
NSOperation、NSOperationQueue 線程同步和線程安全
-
線程安全：若是你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。若是每次運行結果和單線程運行的結果是同樣的，並且其餘的變量的值也和預期的是同樣的，就是線程安全的。 若每一個線程中對全局變量、靜態變量只有讀操做，而無寫操做，通常來講，這個全局變量是線程安全的；如有多個線程同時執行寫操做（更改變量），通常都須要考慮線程同步，不然的話就可能影響線程安全。
-
線程同步：可理解爲線程 A 和 線程 B 一塊配合，A 執行到必定程度時要依靠線程 B 的某個結果，因而停下來，示意 B 運行；B 依言執行，再將結果給 A；A 再繼續操做。
舉個簡單例子就是：兩我的在一塊兒聊天。兩我的不能同時說話，避免聽不清(操做衝突)。等一我的說完(一個線程結束操做)，另外一個再說(另外一個線程再開始操做)。
下面，咱們模擬火車票售賣的方式，實現 NSOperation 線程安全和解決線程同步問題。 場景：總共有50張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另外一個是上海火車票售賣窗口。兩個窗口同時售賣火車票，賣完爲止。
非線程安全的狀況代碼：
/**
* 非線程安全：不使用 NSLock
* 初始化火車票數量、賣票窗口(非線程安全)、並開始賣票
*/
- (void)initTicketStatusNotSave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程
self.ticketSurplusCount = 50;
// 1.建立 queue1,queue1 表明北京火車票售賣窗口
NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
queue1.maxConcurrentOperationCount = 1;
// 2.建立 queue2,queue2 表明上海火車票售賣窗口
NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
queue2.maxConcurrentOperationCount = 1;
// 3.建立賣票操做 op1
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketNotSafe];
}];
// 4.建立賣票操做 op2
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketNotSafe];
}];
// 5.添加操做，開始賣票
[queue1 addOperation:op1];
[queue2 addOperation:op2];
}
/**
* 售賣火車票(非線程安全)
*/
- (void)saleTicketNotSafe {
while (1) {
if (self.ticketSurplusCount > 0) {
//若是還有票，繼續售賣
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
} else {
NSLog(@"全部火車票均已售完");
break;
}
}
}
複製代碼
能夠看到： 在不考慮線程安全，不使用 NSLock 狀況下，獲得票數是錯亂的，這樣顯然不符合咱們的需求，因此咱們須要考慮線程安全問題。
線程安全解決方案：能夠給線程加鎖，在一個線程執行該操做的時候，不容許其餘線程進行操做。iOS 實現線程加鎖有不少種方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/get等等各類方式。這裏咱們使用 NSLock 對象來解決線程同步問題。NSLock 對象能夠經過進入鎖時調用 lock 方法，解鎖時調用 unlock 方法來保證線程安全。
線程安全狀況的代碼：
/**
* 線程安全：使用 NSLock 加鎖
* 初始化火車票數量、賣票窗口(線程安全)、並開始賣票
*/
- (void)initTicketStatusSave {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當前線程
self.ticketSurplusCount = 50;
self.lock = [[NSLock alloc] init]; // 初始化 NSLock 對象
// 1.建立 queue1,queue1 表明北京火車票售賣窗口
NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
queue1.maxConcurrentOperationCount = 1;
// 2.建立 queue2,queue2 表明上海火車票售賣窗口
NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
queue2.maxConcurrentOperationCount = 1;
// 3.建立賣票操做 op1
NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketSafe];
}];
// 4.建立賣票操做 op2
NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
[self saleTicketSafe];
}];
// 5.添加操做，開始賣票
[queue1 addOperation:op1];
[queue2 addOperation:op2];
}
/**
* 售賣火車票(線程安全)
*/
- (void)saleTicketSafe {
while (1) {
// 加鎖
[self.lock lock];
if (self.ticketSurplusCount > 0) {
//若是還有票，繼續售賣
self.ticketSurplusCount--;
NSLog(@"%@", [NSString stringWithFormat:@"剩餘票數:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
[NSThread sleepForTimeInterval:0.2];
}
// 解鎖
[self.lock unlock];
if (self.ticketSurplusCount <= 0) {
NSLog(@"全部火車票均已售完");
break;
}
}
}
複製代碼
能夠看出：在考慮了線程安全，使用 NSLock 加鎖、解鎖機制的狀況下，獲得的票數是正確的，沒有出現混亂的狀況。咱們也就解決了多個線程同步的問題。
NSOperation、NSOperationQueue 經常使用屬性和方法概括
NSOperation 經常使用屬性和方法
取消操做方法
- (void)cancel;可取消操做，實質是標記 isCancelled 狀態。
判斷操做狀態方法
-
- (BOOL)isFinished;判斷操做是否已經結束。 -
- (BOOL)isCancelled;判斷操做是否已經標記爲取消。 -
- (BOOL)isExecuting;判斷操做是否正在在運行。 -
- (BOOL)isReady;判斷操做是否處於準備就緒狀態，這個值和操做的依賴關係相關。
操做同步
-
- (void)waitUntilFinished;阻塞當前線程，直到該操做結束。可用於線程執行順序的同步。 -
- (void)setCompletionBlock:(void (^)(void))block;completionBlock會在當前操做執行完畢時執行completionBlock。 -
- (void)addDependency:(NSOperation *)op;添加依賴，使當前操做依賴於操做 op 的完成。 -
- (void)removeDependency:(NSOperation *)op;移除依賴，取消當前操做對操做 op 的依賴。 -
@property (readonly, copy) NSArray<NSOperation *> *dependencies;在當前操做開始執行以前完成執行的全部操做對象數組。
NSOperationQueue 經常使用屬性和方法
取消/暫停/恢復操做
- (void)cancelAllOperations;能夠取消隊列的全部操做。- (BOOL)isSuspended;判斷隊列是否處於暫停狀態。 YES 爲暫停狀態，NO 爲恢復狀態。- (void)setSuspended:(BOOL)b;可設置操做的暫停和恢復，YES 表明暫停隊列，NO 表明恢復隊列。
操做同步
- (void)waitUntilAllOperationsAreFinished;阻塞當前線程，直到隊列中的操做所有執行完畢。
添加/獲取操做`
- (void)addOperationWithBlock:(void (^)(void))block;向隊列中添加一個NSBlockOperation類型操做對象。- (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait;向隊列中添加操做數組，wait標誌是否阻塞當前線程直到全部操做結束- (NSArray *)operations;當前在隊列中的操做數組（某個操做執行結束後會自動從這個數組清除）。- (NSUInteger)operationCount;當前隊列中的操做數。
獲取隊列
+ (id)currentQueue;獲取當前隊列，若是當前線程不是在NSOperationQueue上運行則返回nil。+ (id)mainQueue;獲取主隊列。
注意： 一、這裏的暫停和取消（包括操做的取消和隊列的取消）並不表明能夠將當前的操做當即取消，而是噹噹前的操做執行完畢以後再也不執行新的操做。 二、暫停和取消的區別就在於：暫停操做以後還能夠恢復操做，繼續向下執行；而取消操做以後，全部的操做就清空了，沒法再接着執行剩下的操做。
- 1. iOS 多線程：『NSOperation、NSOperationQueue』詳盡總結
- 2. iOS多線程：『NSOperation、NSOperationQueue』詳盡總結
- 3. iOS 多線程 NSOperation、NSOperationQueue
- 4. iOS多線程之NSOperation、NSOperationQueue
- 5. 總結NSOperation、NSOperationQueue
- 6. iOS多線程開發-NSOperation/NSOperationQueue淺析
- 7. iOS多線程：『pthread、NSThread』詳盡總結
- 8. iOS 多線程：『RunLoop』詳盡總結
- 9. iOS 多線程：『GCD』詳盡總結
- 10. iOS多線程：『GCD』詳盡總結
- 更多相關文章...
- • C# 多線程 - C#教程
- • Spring體系結構詳解 - Spring教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • 算法總結-回溯法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. iOS 多線程：『NSOperation、NSOperationQueue』詳盡總結
- 2. iOS多線程：『NSOperation、NSOperationQueue』詳盡總結
- 3. iOS 多線程 NSOperation、NSOperationQueue
- 4. iOS多線程之NSOperation、NSOperationQueue
- 5. 總結NSOperation、NSOperationQueue
- 6. iOS多線程開發-NSOperation/NSOperationQueue淺析
- 7. iOS多線程：『pthread、NSThread』詳盡總結
- 8. iOS 多線程：『RunLoop』詳盡總結
- 9. iOS 多線程：『GCD』詳盡總結
- 10. iOS多線程：『GCD』詳盡總結