多線程之NSOperation的進階使用和探討

本文將會從多個方面探討NSOperation類和NSOperationQueue類的相關內容

一、簡介

NSOperation類是iOS2.0推出的，通過NSThread實現的,但是效率一般。
從OS X10.6和iOS4推出GCD時，又重寫了NSOperation和NSOperationQueue，NSOperation和NSOperationQueue分別對應GCD的任務和隊列，所以NSOPeration和NSOperationQueue是基於GCD更高一層的封裝，而且完全地面向對象。但是比GCD更簡單易用、代碼可讀性也更高。NSOperation和NSOperationQueue對比GCD會帶來一點額外的系統開銷，但是可以在多個操作Operation中添加附屬。

二、知識概括

從NSOperation的思維導圖瞭解的這個類相關的整體的知識點：

NSOperation和NSOperationQueue是基於GCD的更高一層的封裝，分別對應GCD的任務和隊列，完全地面向對象。可以通過start方法直接啓動NSOperation子類對象，並且默認同步執行任務，將NSOperation子類對象添加到NSOperationQueue中，該隊列默認併發的調度任務。

開啓操作有二種方式，一是通過start方法直接啓動操作，該操作默認同步執行，二是將操作添加到NSOperationQueue中，然後由系統從隊列中獲取操作然後添加到一個新線程中執行，這些操作默認併發執行。

具體實現如下：

方式一：直接由NSOperation子類對象啓動。
首先將需要執行的操作封裝到NSOperation子類對象中，然後該對象調用Start方法。

方式二：當添加到NSOperationQueue對象中，由該隊列對象啓動操作。

將需要執行的操作封裝到NSOperation子類對象中
將該對象添加到NSOperationQueue中
系統將NSOperation子類對象從NSOperationQueue中取出
將取出的操作放到一個新線程中執行

使用隊列來執行操作，分爲2個階段：第一階段：添加到線程隊列的過程，是上圖的步驟1和2。第二階段：系統自動從隊列中取出線程，並且自動放到線程中執行，是上圖的步驟3和4。

接下來相關內容的總結：

1. NSOperation

NSOperation是一個和任務相關的抽象類，不具備封裝操作的能力，必須使用其子類。
使用NSOperation⼦類的方式有3種：

系統實現的具體子類：NSInvocationOperation
系統實現的具體子類：NSBlockOperation
自定義子類,實現內部相應的⽅法
該類是線程安全的，不必管理線程生命週期和同步等問題。

a. NSInvocationOperation子類

NSInvocationOperation是NSOperation的子類。創建操作對象的方式有2種，使用initWithTarget:selector:object:創建sel參數是一個或0個的操作對象。使用initWithInvocation:方法，添加sel參數是0個或多個操作對象。在未添加到隊列的情況下，創建操作對象的過程中不會開闢線程，會在當前線程中執行同步操作。創建完成後，直接調用start方法，會啓動操作對象來執行操，或者添加到NSOperationQueue隊列中。無論使用該子類的哪個在初始化的方法，都會在添加一個任務。和NSBlockOperation子類不同的是，因爲沒有額外添加任務的方法，使用NSInvocationOperation創建的對象只會有一個任務。

默認情況下，調用start方法不會開闢一個新線程去執行操作，而是在當前線程同步執行任務。只有將其放到一個NSOperationQueue中，纔會異步執行操作

b. NSBlockOperation子類

可以通過blockOperationWithBlock:創建NSBlockOperation對象,在創建的時候也添加一個任務。如果想添加更多的任務，可以使用addExecutionBlock:方法。也可以通過init：創建NSBlockOperation對象。但是這種創建方式並不會在創建對象的時候添加任務，同樣可以使用addExecutionBlock:方法添加任務。對於啓動操作和NSInvocationOperation類一樣，都可以通過調用start方法和添加NSOperationQueue中來執行操作。

關於任務的的同步、異步的執行可以總結幾點：

任務數爲1時，即使用blockOperationWithBlock:方法或者init:與addExecutionBlock:二個方法結合的方式創建的唯一一個任務時，不會開闢新線程，直接在當前線程同步執行任務。
任務數大於1時，使用blockOperationWithBlock:方法或者init:與addExecutionBlock:二個方法結合的方式創建的一個任務A，不會開闢線程，直接在當前線程同步執行任務。而NSBlockOperation對象使用addExecutionBlock:方法添加的其他任務會開闢新線程，異步執行任務。
將操作放到一個NSOperationQueue中，會異步執行操作任務。

注意：不可在completionBlock屬性的block中追加任務，因爲在操作已經啓動執行中或者結束後不可以添加block任務。

c. 自定義子類

一般類NSInvocationOperation、NSBlockOperation就可以滿足使用需要，當然還可以自己自定義子類。

創建的子類時，需要考慮到可能會添加到串行和併發隊列的不同情況，需要重寫不同的方法。對於串行操作，僅僅需要重新main方法就行，在這個方法中添加想要實現的功能。對於併發操作，重寫四個方法：start、asynchronous、executing、finished。並且需要自己創建自動釋放池，因爲異步操作無法訪問主線程的自動釋放池。

注意：在自定義子類時，經常通過cancelled屬性檢查方法是否取消，並且對取消的做出響應。

2. NSOperationQueue

使用將NSOperation對象添加NSOperationQueue中，來管理操作對象是非常方便的。因爲當我們把操作對象添加到NSOperationQueue對象後，該NSOperationQueue對象從線程中拿取操作、以及分配到對應線程的工作都是由系統處理的。

只要是創建了隊列，在隊列中的操作，就會在子線程中執行，並且默認併發操作。添加到子隊列NSOperationQueue實例中的操作，都是異步執行

a.操作對象添加到NSOperationQueue對象中

添加的方式有3種。

addOperation:添加一個操作
addOperationWithBlock:，系統自動封裝成一個NSBlockOperation對象，然後添加到隊列中
addOperations:waitUntilFinished:添加多個操作
操作對象添加到NSOperationQueue之後,通常短時間內就會運行。但是如果存在依賴,或者整個隊列被暫停等原因,也可能需要等待。

操作對象添加NSOperationQueue中後，不要再修改操作對象的狀態。因爲操作對象可能會在任何時候運行,因此改變操作對象的依賴或數據會產生無法預估的問題。只能查看操作對象的狀態, 比如是否正在運行、等待運行、已經完成等。

b. 設置最多併發數

雖然NSOperationQueue類設計用於併發執行操作，但是也可以強制讓單個隊列一次只能調度一個操作對象。setMaxConcurrentOperationCount:方法可以設置隊列的最大併發操作數量。當設爲1就表示NSOperationQueue實例每次只能執行一個NSOperation子類對象。不過操作對象執行的順序會依賴於其它因素,比如操作是否準備好和操作對象的優先級等。因此串行化的operation queue並不等同於GCD中的串行dispatch queue。

maxConcurrentOperationCount默認是-1，不可設置爲0。如果沒有設置最大併發數，那麼併發的個數是由系統內存和CPU決定的。

相關概念：

併發數: NSOperationQueue隊列裏同時能調度的NSOperation對象數。
最大併發數: 同一時間最多能調度的NSOperation對象數。

c. 進度修改

一個操作執行還未完成時，我們可能需要讓該任務暫停、可能之後在進行某些操作後又希望繼續執行。爲了滿足這個需要，蘋果公司，爲我們提供了suspended屬性。當可能我們不想執行某些操作時，可以個cancel方法、cancelAllOperations方法可以取消操作對象，一旦調用了這2個方法，操作對象將無法恢復。具體如下：

對於暫停操作，當NSOperationQueue對象屬性suspended設置爲YES，隊列會停止對任務調度。對那些還在線程中的操作有影響的。如果任務正在執行將不會受到影響，因爲任務已經被隊列調度到一個線程上並執行。

對於繼續操作，當屬性suspended設置爲NO會繼續執行線程操作。隊列將積極啓動隊列中已準備執行的操作。

一旦NSOperation子類操作對象添加到NSOperationQueue對象中,該隊列就擁有了該操作對象並且不能刪除操作對象,如果不想執行操作對象，只能取消該操作對象。關於取消操作，可以分爲2種情況，取消一個操作和取消一個隊列的全部操作二種情況。調用NSOperation類實例的cancel方法取消單個操作對象。調用NSOperationQueue類實例cancelAllOperations方法取消隊列中全部操作對象。

對於隊列中的操作，只有操作標記爲已結束才能被隊列移除。在隊列中未被調度的操作，會調用start方法執行操作，以便操作對象處理取消事件。然後標記這些操作對象爲已結束。對於正在線程中執行其任務的操作對象，正在執行的任務會繼續執行，該操作對象會被標記經結束。

注意：只會停止調度隊列中操作對象，正在執行任務的依然會執行，且取消不可恢復。

d.作用

NSOperation對象可以調⽤start⽅法來執⾏任務,但默認是同步執行的（可以創建異步操作，NSBlockOperation添加操作數大於1時，除第一個任務外，其任務就是異步執行）。如果將NSOperation添加到NSOperationQueue中，之後操作就就由系統管理，系統先從隊列中取出操作，然後放到一個新線程中異步執行。總結:添加操作到NSOperationQueue中，自動執行操作，自動開啓線程

f. 獲取隊列

系統提供了2個，可以獲取當前隊列和主隊列。可以通過類屬性currentQueue獲取當前隊列。可以通過類屬性mainQueue獲取主隊列.

3.依賴

操作對象可以添加和移除依賴。當一個操作對象添加了依賴，被依賴的操作對象就會先執行，當被依賴的操作對象執行完纔會當前的操作對象。添加到不同線程對象中的操作對象依然彼此間可以單方面依賴。切記循環依賴的情況。這樣會產生死循環。

可以通過addDependency方法添加一個或者多個依賴的對象。eg:[A addDependency:B];

操作A依賴於操作B。操作對象會管理自己的依賴，因此在不相同隊列中的操作對象可以建立依賴關係。但是**一定要在添加線程對象NSOperationQueue之前，進行依賴設置。**設置依賴可以保證執行順序，操作添加到隊列添加的順序並不能決定執行順序，執行的順序取決於多種因素比如依賴、優先級等。

調用removeDependency:方法移除依賴。

如圖，箭頭方向就是依賴的對象，從圖中可知，A依賴b，而b依賴C。所以三者的執行順序是C–>b–>A

4.線程安全

在NSOperation實例在多線程上執行是安全的，不需要添加額外的鎖

5.cancel方法

只會對未執行的操作有效，正在執行的操作，在收到cancel消息後，依然會執行。

調用操作隊列中的操作的cancel方法，且該操作隊列具有未完成的依賴操作時，那麼這些依賴操作會被忽略。由於操作已經被取消，因此此行爲允許隊列調用操作的start方法，以便在不調用其主方法的情況下從隊列中刪除操作。如果對不在隊列中的操作調用cancel方法，則該操作立即標記爲已取消。

6.狀態屬性

一個線程有未創建、就緒、運行中、阻塞、消亡等多個狀態。而操作對象也有多種狀態：executing(執行中)、finished(完成)、ready(就緒)狀態，這三個屬性是蘋果公司，提供給我們用於觀察操作對象狀態的時候用的。因爲這個三個屬性KVC與KVO兼容的,因此可以監聽操作對象狀態屬性。

7.操作完成

a. 監聽操作完成
當我們可能需要在某個操作對象完成後添加一些功能，此時就可以用屬性completionBlock來添加額外的內容了。

operation.completionBlock = ^{
  // 完成操作後，可以追加的內容
};

b. 等待操作完成

這個有2種情況：一是等待單個操作對象，而是等待隊列裏全部的操作。

如果想等待整個隊列的操作，可以同時等待一個queue中的所有操作。使用NSOperationQueue的waitUntilAllOperationsAreFinished方法。在等待一個隊列時,應用的其它線程仍然可以往隊列中添加操作,因此可能會加長線程的等待時間。

// 阻塞當前線程，等待queue的所有操作執行完畢
[queue waitUntilAllOperationsAreFinished];

對於單個操作對象，爲了最佳的性能,儘可能設計異步操作,這樣可以讓應用在正在執行操作時可以去處理其它事情。如果需要當前線程操作對象處理完成後的結果,可以使用NSOperation的waitUntilFinished方法阻塞當前線程，等待操作完成。通常應該避免這樣編寫,阻塞當前線程可能是一種簡便的解決方案,但是它引入了更多的串行代碼,限制了整個應用的併發性,同時也降低了用戶體驗。絕對不要在應用主線程中等待一個Operation,只能在非中等待。因爲阻塞主線程將導致應用無法響應用戶事件,應用也將表現爲無響應。

// 會阻塞當前線程，等到某個operation執行完畢
[operation waitUntilFinished];

8.執行順序

添加到NSOperationQueue中的操作對象，其執行順序取決於2點：
1.首先判斷操作對象是否已經準備好：由對象的依賴關係確定
2.然後再根據所有操作對象的相對優先級來確定：優先級等級則是操作對象本身的一個屬性。默認所有操作對象都擁有“普通”優先級,不過可以通過qualityOfService:方法來提升或降低操作對象的優先級。優先級只能應用於相同隊列中的操作對象。如果應用有多個操作隊列,每個隊列的優先級等級是互相獨立的。因此不同隊列中的低優先級操作仍然可能比高優先級操作更早執行。

對於優先級，我們可以使用屬性queuePriority給某個操作對象設置高底，優先級高的任務，調用的機率會更大, 並不能保證執行順序。並且優先級不能替代依賴關係,優先級只是對已經準備好的操作對象確定執行順序。先滿足依賴關係,然後再根據優先級從所有準備好的操作中選擇優先級最高的那個執行。

9.服務質量

根據CPU，網絡和磁盤的分配來創建一個操作的系統優先級。一個高質量的服務就意味着更多的資源得以提供來更快的完成操作。涉及到CPU調度的優先級、IO優先級、任務運行所在的線程以及運行的順序等等

通過設置屬性qualityOfService來設置服務質量。QoS 有五種優先級，默認爲NSQualityOfServiceDefault。它的出現統一了Cocoa中所有多線程技術的優先級。在此之前，NSOperation和NSThread都通過threadPriority來指定優先級，而 GCD 則是根據 DISPATCH_QUEUE_PRIORITY_DEFAULT 等宏定義的整形數來指定優先級。正確的使用新的 QoS 來指定線程或任務優先級可以讓 iOS 更加智能的分配硬件資源，以便於提高執行效率和控制電量。

三、相關類介紹

NSOperation

NSOperation是NSObject的子類，表示單個工作單元。它是一個與任務的相關抽象類，爲狀態、優先級、依賴關係和管理提供了一個有用的、線程安全的結構。

創建自定義NSOperation子類是沒有意義的，Foundation提供了具體的實現的子類：NSBlockOperation和NSInvocationOperation。

適合於NSOperation的任務的例子包括網絡請求、圖像調整、文本處理或任何其他可重複的、結構化的、長時間運行的任務，這些任務會產生關聯的狀態或數據。

概觀

因爲NSOperation類是一個抽象類，並不具備封裝操作的能力，所以不能直接使用該類，而是應該使用其子類來執行實際的任務。其子類包括2種，系統定義的子類(NSInvocationOperation或NSBlockOperation)和自定義的子類。雖然NSOperation類是抽象類，但是該類的基本實現中包括了安全執行任務的重要邏輯。這個內置邏輯的存在可以讓你專注於任務的實際實現,而不是專注於編寫能保證它與其他系統對象的正常工作的粘合代碼。

一個操作對象是一個單發對象,也就是說，一旦它執行了其任務,將不能再執行一遍。通常通過添加他們到一個操作隊列(NSOperationQueue類的一個實例)中來執行操作。操作隊列通過讓操作在輔助線程(非主線程)上運行,或間接使用libdispatch庫(也稱爲GCD)直接來執行其操作。

如果不想使用一個操作隊列,可以調用start方法直接來執行一個操作。手動執行操作會增加更多的代碼負擔,因爲開啓不在就緒狀態的操作會引發異常。ready屬性表示操作的就緒狀態。

操作依賴

依賴是一種按照特定順序執行操作的便捷方式。可以使用addDependency:、removeDependency:方法給操作添加和刪除依賴。默認情況下,直到具有依賴的操作對象的所有依賴都執行完成纔會認爲操作對象是ready(就緒)狀態，。一旦最後一個依賴操作完成,這個操作對象會變成就緒狀態並且可以執行。

NSOperation支持的依賴是不會區分其操作是成功的完成還是失敗的完成。(換句話說,取消操作也視爲完成。)由你來決定有依賴的操作在其所依賴的操作被取消或沒有成功完成任務的情況下是否應該繼續。這可能需要合併一些額外的錯誤跟蹤功能到操作對象裏。

兼容KVO的屬性

NSOperation類對其一些屬性是鍵值編碼(KVC)和鍵值觀察(KVO)兼容的。如有需要,可以觀察這些屬性來控制應用程序的其他部分。使用以下鍵路徑來觀察屬性：

isCancelled - 只讀
isAsynchronous - 只讀
isExecuting - 只讀
isFinished - 只讀
isReady - 只讀
dependencies - 只讀
queuePriority - 讀寫
completionBlock - 讀寫

雖然可以爲這些屬性添加觀察者,但是不應該使用Cocoa bindings來把它們和用戶界面相關的元素綁定。用戶界面相關的代碼通常只有在應用程序的主線程中執行。因爲一個操作可以在任何線程上執行,該操作KVO通知同樣可能發生在任何線程。

如果你爲之前的屬性提供了自定義的實現,那麼該實現內容必須保持與KVC和KVO的兼容。如果你爲NSOperation對象定義了額外的屬性,建議你同樣需要讓這些屬性保持KVC和KVO兼容。

多核注意事項

可以從多線程中安全地調用NSOperation對象的方法而不需要創建額外的鎖來同步存取對象。這種行爲是必要的,因爲一個操作的創建和監控通常在一個單獨的線程上。

當子類化NSOperation類時,必須確保任何重寫的方法能在多個線程中是安全的調用。如果實現子類中自定義方法,比如自定義數據訪問器(accessors，getter),必須確保這些方法是線程安全的。因此,訪問任何數據變量的操作必須同步,以防止潛在的數據損壞。更多關於信息同步的，可以查看Threading Programming Guide。

異步操作 VS 同步操作

如果想要手動執行操作對象而不是將其添加到一個隊列中,那麼可以設計同步或異步的二種方式來執行操作。操作對象默認是同步的。在同步操作中,操作對象不會創建一個單獨的線程來運行它的任務。當直接調用同步操作的start方法時,該操作會在當前線程中立即執行。等到這個對象的開始(start)方法返回給調用者時，表示該任務完成。

當你調用一個異步操作的start方法時,該方法可能在相應的任務完成前返回。一個異步操作對象負責在一個單獨線程上調度任務。通過直接開啓新一個線程、調用一個異步方法,或者提交一個block到調度隊列來執行這個操作。一個異步操作對象可以直接啓動一個新線程。(具有開闢新線程的能力，但是不一定就好開啓新線程，因爲CPU資源有限，不可能開啓無限個線程)

如果使用隊列來執行操作,將他們定義爲同步操作是非常簡單的。如果手動執行操作,可以將操作對象定義爲異步的。定義一個異步操作需要更多的工作,因爲你必須監控正在進行的任務的狀態和使用報告KVO通知狀態的變化。但在你想確保手動執行操作不會阻塞調用線程的情況下定義異步操作是特別有用的。

當添加一個操作到一個操作隊列中,隊列中操作會忽略了asynchronous屬性的值,總是從一個單獨的線程調用start方法。因此,如果你總是通過把操作添加到操作隊列來運行操作,沒有理由讓他們異步的。

子類化註釋

NSOperation類提供了基本的邏輯來跟蹤操作的執行狀態,但必須從它派生出子類做實際工作。如何創建子類依賴於該子類設計用於併發還是非併發。

方法的重載

對於非併發操作,通常只覆蓋一個方法

main

在該方法中,需要給執行特定的任務添加必要的代碼。當然,也可以定義一個自定義的初始化方法,讓它更容易創建自定義類的實例。你可能還想定義getter和setter方法來從操作訪問數據。然而,如果你定義定製了getter和setter方法,你必須確保這些方法在多個線程調用是安全的。

如果你創建一個併發操作,需要至少重寫下面的方法和屬性:

start
asynchronous
executing
finished

在併發操作中,start方法負責以異步的方式啓動操作。從這個方法決定否生成一個線程或者調用異步函數。在將要開始操作時,start方法也應該更新操作executing屬性的執行狀態作爲報告。這可以通過發送executing這個鍵路徑的KVO通知,讓感興趣的客戶端知道該操作現在正在運行中。executing屬性還必須以線程安全的方式提供狀態。

在將要完成或取消任務時,併發操作對象必鬚生成isExecuting和isFinished鍵路徑的KVO通知爲來標記操作的最終改變狀態。(在取消的情況下,更新isFinished鍵路徑仍然是重要的,即使操作沒有完全完成其任務。已經排隊的操作必須在隊列刪除操作前報告)除了生成KVO通知,executing和finished屬性的重寫還應該繼續根據操作的狀態的精確值來報告。

重要：
在start方法中，任何時候都不應該調用super。當定義一個併發操作時，需要自己提供與默認start方法相同的行爲，包括啓動任務和生成適當的KVO通知。start方法還應該在實際開始任務之前檢查操作本身是否被取消。

對於併發操作，除了上面描述的方法之外，應該不需要重寫其他方法。然而，如果你自定義操作的依賴特性，可能必須重寫額外的方法並提供額外的KVO通知。對於依賴項，這可能只需要提供isReady鍵路徑的通知。因爲dependencies屬性包含了一系列依賴操作，所以對它的更改已經由默認的NSOperation類處理。

維護操作對象狀態

操作對象通過維護內容的狀態信息來決定何時執行是安全的和在操作的生命週期期間通知外部其任務進展。自定義子類需要維護狀態信息來保證代碼中執行操作的正確性。操作狀態關聯的鍵路徑有：

isReady

該鍵路徑讓客戶端知道一個操作何時可以準備執行。當操作馬上可以執行時該屬性值爲true，當其依賴中有未完成，則是false。
大多數情況下，沒必要自己管理這個鍵路徑的狀態。如果操作的就緒狀態是由操作依賴因素決定(例如在你的程序中的一些外部條件)，那麼你可以提供ready屬性的實現並且跟蹤操作的就緒狀態。雖然只在外部狀態允許的情況下創建操作對象時通常更簡單。

在macOS 10.6或更高版本中，如果取消的操作，正在等待一個或多個依賴操作完成，那麼這些依賴項將被忽略，該屬性的值將更新成已經準備好運行了。這種行爲使操作隊列有機會更快地將已取消的操作從隊列中清除出去。
isExecuting

該鍵路徑讓客戶端知道操作是否在正在地執行它所分配的任務。如果操作正在處理其任務，則值爲true;否則值爲false。

如果替換操作對象的start方法，則還必須替換executing屬性，並在操作的執行狀態發生變化時生成KVO通知。
isFinished

該鍵路徑讓客戶端知道操作成功地完成了任務或者被取消並退出。直到isFinished這個鍵路徑的值變爲true，操作對象纔會清除依賴。類似的，直到finished屬性的是true時，一個操作隊列纔會退出操作隊列。因此，將操作標記爲已完成對於防止隊列備份正在進行的操作或已取消的操作非常重要。

如果替換操作對象的start方法，則還必須替換executing屬性，並在操作的執行狀態發生變化時生成KVO通知。
isCancelled

isCancelled鍵路徑讓客戶端知道請求取消某個操作。支持自願取消，但不鼓勵主動發送這個鍵路徑的KVO通知。

響應取消命令

一旦將操作添加到隊列中，操作就不在你的控制範圍內了。隊列接管並處理該任務的調度。但是，如果你最終決定不想執行某些操作，例如用戶按下取消按鈕或退出應用程序時，你可以取消操作，以防止消耗不必要地CPU時間。可以通過調用操作對象本身的cancel方法或調用NSOperationQueue類的cancelAllOperations方法來實現這一點。

取消一個操作不會立即迫使它停止它正在做的事情。雖然所有操作都需要考慮cancelled屬性中的值，但是必須顯式檢查該屬性中的值，並根據需要中止。NSOperation的默認實現包括取消檢查。例如，如果在調用一個操作的start方法之前取消該操作，那麼start方法將退出而不啓動任務。

提示

在macOS 10.6或更高版本中，如果調用操作隊列中的操作的cancel方法，且該操作隊列具有未完成的依賴操作，那麼這些依賴操作隨後將被忽略。由於操作已經被取消，因此此行爲允許隊列調用操作的start方法，以便在不調用其主方法的情況下從隊列中刪除操作。如果對不在隊列中的操作調用cancel方法，則該操作立即標記爲已取消。在每種情況下，將操作標記爲已準備好或已完成時，會生成適當的KVO通知。

在你編寫的任何定製代碼中，都應該始終支持取消語義。特別是，主任務代碼應該定期檢查cancelled屬性的值。如果屬性值爲YES，則操作對象應該儘快清理並退出。如果您實現了一個自定義的start方法，那麼該方法應該包含早期的取消檢查並適當地執行。您的自定義開始方法必須準備好處理這種類型的提前取消。

除了在操作被取消時簡單地退出之外，將已取消的操作移動到適當的最終狀態也很重要。具體來說，如果您自己管理finished和executing屬性的值(可能是因爲你正在實現併發操作)，那麼你必須更新更新相應地屬性。具體來說，你必須將finished返回的值更改爲YES，將executing返回的值更改爲NO。即使操作在開始執行之前被取消，你也必須進行這些更改。

屬性和方法

初始化

// 返回一個初始化的NSOperation對象
- (instancetype)init;// 父類 NSObject方法

執行操作

// 開啓操作
//在當前任務狀態和依賴關係合適的情況下，啓動NSOperation的main方法任務，需要注意缺省實現只是在當前線程運行。如果需要併發執行，子類必須重寫這個方法，並且使屬性asynchronous返回YES。
- (void)start;
// 執行接收者(NSOperation)的非併發任務。操作任務的入口，一般用於自定義NSOperation的子類
- (void)main;
// 操作主任務完成後執行這個block
// 由於NSOperation有可能被取消，所以在block運行的代碼應該和NSOperation的核心任務無關
@property (nullable, copy) void (^completionBlock)(void);

取消操作

// 通知操作對象(NSOperation)停止執行其任務。標記isCancelled狀態。
// 調用後不會自動馬上取消，需要通過isCancelled方法檢查是否被取消，然後自己編寫代碼退出當前的操作
- (void)cancel;

獲取操作狀態

// Boolean 值，表示操作是否已經取消
@property (readonly, getter=isCancelled) BOOL cancelled;
// Boolean 值，表示操作是否正在執行
@property (readonly, getter=isExecuting) BOOL executing;
// Boolean 值，表示操作是否正完成執行
@property (readonly, getter=isFinished) BOOL finished;
// Boolean 值，表示操作是否異步執行任務
@property (readonly, getter=isAsynchronous) BOOL asynchronous ;
// Boolean 值，表示操作是否可以立即執行(準備完畢狀態)
@property (readonly, getter=isReady) BOOL ready;
// 操作的名字
@property (nullable, copy) NSString *name;

管理依賴

// 添加依賴，使接收器依賴於指定完成操作。
// 如：[op1 addDependency:op2]; op2先執行，op1後執行
- (void)addDependency:(NSOperation *)op;

// 取消依賴，移出接收方對指定操作的依賴
// 注意：操作對象的依賴不能在操作隊列執行時取消
- (void)removeDependency:(NSOperation *)op;

// 在當前對象開始執行之前必須完成執行的操作對象數組。
@property (readonly, copy) NSArray<NSOperation *> *dependencies;

執行優先級

// 操作獲取系統資源的相對的重要性。系統自動合理的管理隊列的資源分配
@property NSQualityOfService qualityOfService;

等待一個操作對象

// 阻塞當前線程的執行，直到操作對象完成其任務。可用於線程執行順序的同步。
- (void)waitUntilFinished;

常量

// 這些常量允許您對執行操作的順序進行優先排序。
NSOperationQueuePriority
// 用於表示工作對系統的性質和重要性。服務質量較高的類比服務質量較低的類獲得更多的資源。
NSQualityOfService

// NSOperation優先級的枚舉
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
	NSOperationQueuePriorityVeryLow = -8L,
	NSOperationQueuePriorityLow = -4L,
	NSOperationQueuePriorityNormal = 0,
	NSOperationQueuePriorityHigh = 4,
	NSOperationQueuePriorityVeryHigh = 8
};

在iOS8之後蘋果提供了幾個Quality of Service枚舉來使用：user interactive, user initiated, utility 和 background。通過這些枚舉告訴系統我們在進行什麼樣的工作，然後系統會通過合理的資源控制來最高效的執行任務代碼，其中主要涉及到CPU調度的優先級、IO優先級、任務運行在哪個線程以及運行的順序等等，我們可以通過一個抽象的Quality of Service枚舉參數來表明任務的意圖以及類別

//與用戶交互的任務，這些任務通常跟UI級別的刷新相關，比如動畫，這些任務需要在一瞬間完成.
NSQualityOfServiceUserInteractive
// 由用戶發起的並且需要立即得到結果的任務，比如滑動scroll view時去加載數據用於後續cell的顯示，這些任務通常跟後續的用戶交互相關，在幾秒或者更短的時間內完成
NSQualityOfServiceUserInitiated
// 一些可能需要花點時間的任務，這些任務不需要馬上返回結果，比如下載的任務，這些任務可能花費幾秒或者幾分鐘的時間
NSQualityOfServiceUtility
// 一些可能需要花點時間的任務，這些任務不需要馬上返回結果，比如下載的任務，這些任務可能花費幾秒或者幾分鐘的時間
NSQualityOfServiceBackground
// 一些可能需要花點時間的任務，這些任務不需要馬上返回結果，比如下載的任務，這些任務可能花費幾秒或者幾分鐘的時間
NSQualityOfServiceDefault

eg:Utility 及以下的優先級會受到 iOS9 中低電量模式的控制。另外，在沒有用戶操作時，90% 任務的優先級都應該在 Utility 之下。

NSBlockOperation

NSOperation的子類，管理一個或多個塊的併發執行的操作。

概觀

NSBlockOperation類是NSOperation的一個具體子類，它管理一個或多個塊的併發執行。可以使用此對象一次執行多個塊，而不必爲每個塊創建單獨的操作對象。當執行多個塊時，只有當所有塊都完成執行時，才認爲操作本身已經完成。

添加到操作中的塊(block)將以默認優先級分配到適當的工作隊列。

方法屬性

管理操作中的塊

// 創建並返回一個NSBlockOperation對象，並添加指定的塊到該對象中。
+ (instancetype)blockOperationWithBlock:(void (^)(void))block;
// 將指定的塊添加到要執行的塊列表中。
- (void)addExecutionBlock:(void (^)(void))block;
// 與接收器關聯的塊。
@property (readonly, copy) NSArray<void (^)(void)> *executionBlocks;

NSInvocationOperation

NSOperation的子類,管理作爲調用指定的單個封裝任務執行的操作。

概觀

NSInvocationOperation類是NSOperation的一個具體子類，可以使用它來初始化一個包含在指定對象上調用選擇器的操作。這個類實現了一個非併發操作。

方法屬性

初始化

// 返回一個用指定的目標和選擇器初始化的NSInvocationOperation對象。
- (instancetype)initWithTarget:(id)target selector:(SEL)sel object:(nullable id)arg;
// 返回用指定的調用對象初始化的NSInvocationOperation對象。
- (instancetype)initWithInvocation:(NSInvocation *)inv NS_DESIGNATED_INITIALIZER;

獲取屬性

// 接收者的調用對象。
@property (readonly, retain) NSInvocation *invocation;
// 調用或方法的結果
@property (nullable, readonly, retain) id result;

常量

// 如果調用result方法時出現錯誤，則由NSInvocationOperation引發的異常名稱。
Result Exceptions

NSOperationQueue

管理操作執行的隊列。

概觀

NSObject子類。操作隊列根據其優先級和就緒程度執行其排隊的NSOperation對象。在添加到操作隊列後，操作將保持在其隊列中，直到它報告其任務結束爲止。在隊列被添加後，您不能直接從隊列中刪除操作。

提示：
操作隊列保留操作直到完成，隊列本身保留到所有操作完成。使用未完成的操作掛起操作隊列可能導致內存泄漏。

確定執行順序

隊列中的操作是根據它們的狀態、優先級和依賴關係來組織的，並相應地執行。如果所有排隊的操作都具有相同的queuePriority並準備好在放入隊列時執行(也就是說，它們的就緒屬性返回yes)，那麼它們將按照提交到隊列的順序執行。否則，操作隊列總是執行優先級最高的操作。

但是不應該依賴隊列語義來確保操作的特定執行順序，因爲操作準備狀態的更改可能會更改最終的執行順序。操作間依賴關係爲操作提供了絕對的執行順序，即使這些操作位於不同的操作隊列中。一個操作對象直到它的所有依賴操作都完成執行後才被認爲準備好執行。

取消操作

結束任務並不一定意味着操作完成了任務，一個操作也可以被取消。取消操作對象會將該對象留在隊列中，但會通知該對象應該儘快停止其任務。對於當前正在執行的操作，這意味着操作對象必須檢查取消狀態，停止它正在執行的操作，並將自己標記爲已結束。對於在隊列排隊但尚未執行的操作，隊列仍然需要調用操作對象的start方法，以便它能夠處理取消事件並將自己標記爲已結束。

提示
取消操作會導致操作忽略它可能具有的依賴項。這種行爲使隊列能夠儘快執行操作的start方法。開始方法依次將操作移動到結束狀態，以便可以將其從隊列中刪除。

KVO兼容屬性

NSOperationQueue類是符合鍵值編碼(KVC)和鍵值觀察(KVO)的。可以根據需要觀察這些屬性，以控制應用程序的其他部分。要觀察屬性，使用以下鍵路徑:

operations - 只讀
operationCount - 只讀
maxConcurrentOperationCount - 讀寫
suspended - 讀寫
name - 讀寫

雖然可以將觀察者附加到這些屬性，但是不應該使用Cocoa bindings(綁定)將它們綁定到用戶界面的相關的元素。與用戶界面關聯的任務通常只能在應用程序的主線程中執行。然而與操作隊列相關聯的KVO通知可能發生在任何線程中。

線程安全

從多個線程中使用一個NSOperationQueue對象是安全的，無需創建額外的鎖來同步對該對象的訪問。

操作隊列使用調度框架來啓動其操作的執行。因此，操作總是在單獨的線程上執行，而不管它們是被指定爲同步的還是異步的。

屬性&方法

訪問特定操作隊列

// 返回與主線程關聯的操作隊列。缺省總是有一個queue。
@property (class, readonly, strong) NSOperationQueue *mainQueue;
// 返回啓動當前操作的操作隊列。
@property (class, readonly, strong, nullable) NSOperationQueue *currentQueue;

管理隊列中的操作

// 將指定的操作添加到接收器。
- (void)addOperation:(NSOperation *)op;
//將指定的操作添加到隊列。
- (void)addOperations:(NSArray<NSOperation *> *)ops waitUntilFinished:(BOOL)wait;
// 在操作中包裝指定的塊並將其添加到接收器。
- (void)addOperationWithBlock:(void (^)(void))block;
// 當前在隊列中的操作。
@property (readonly, copy) NSArray<__kindof NSOperation *> *operations;
// 隊列中當前的操作數。
@property (readonly) NSUInteger operationCount;
// 取消所有排隊和執行的操作。
- (void)cancelAllOperations;
// 阻塞當前線程，直到所有接收者的排隊操作和執行操作完成爲止
- (void)waitUntilAllOperationsAreFinished;

管理操作的執行

// 應用於使用隊列執行的操作的默認服務級別。
@property NSQualityOfService qualityOfService;
// 可以同時執行的隊列操作的最大數量。
@property NSInteger maxConcurrentOperationCount;
// 在隊列中併發執行的默認最大操作數。
NSOperationQueueDefaultMaxConcurrentOperationCount

暫停執行

// 一個布爾值，表示隊列是否在主動調度要執行的操作。(suspended 掛起，暫停的)
@property (getter=isSuspended) BOOL suspended;

當該屬性的值爲NO時，隊列將積極啓動隊列中已準備執行的操作。將此屬性設置爲YES時，可以防止隊列啓動任何排隊着的操作，但是已經執行的操作將繼續執行。可以繼續將操作添加到已掛起的隊列中，但在將此屬性更改爲NO之前，這些操作不會安排執行。
操作只有在結束執行後才從隊列中刪除。但是，爲了結束執行，必須首先啓動一個操作。因爲掛起的隊列不會啓動任何新操作，所以它不會刪除當前排隊但未執行的任何操作(包括已取消的操作)。

可以使用鍵值觀察監視此屬性值的更改。配置一個觀察者來監視操作隊列的suspended鍵路徑。
此屬性的默認值是NO。

隊列配置

// 操作隊列名稱
@property (nullable, copy) NSString *name;
// 用於執行操作的調度隊列。
@property (nullable, assign /* actually retain */) dispatch_queue_t underlyingQueue;

四、使用

1. NSInvocationOperation

創建：調用Start方法開啓。默認情況下，調用start方法不會開闢一個新線程去執行操作，而是在當前線程同步執行操作。

創建方式一：使用initWithInvocation方法，可以設置0個或多個參數

NSMethodSignature *sig = [[self class] instanceMethodSignatureForSelector:@selector(addSig:)];
NSInvocation *invo = [NSInvocation invocationWithMethodSignature:sig];
NSString * info = @"NSMethodSignature";
[invo setTarget:self];
[invo setSelector:@selector(addSig:)];
 //argumentLocation 指定參數，以指針方式
 // idx 參數索引，第一個參數的起始index是2，因爲index爲1，2的分別是self和selector
[invo setArgument:(__bridge void *)(info) atIndex:2];
NSInvocationOperation *invocationOp = [[NSInvocationOperation alloc] initWithInvocation:invo];
[invocationOp start];

創建方式二：使用initWithTarget

// 初始化
NSInvocationOperation *invocationOp = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOpSel:) object:@"111"]; // 操作的第一個
// 執行
[invocationOp start];

2. NSBlockOperation

創建第一個操作任務，一般不會開闢新線程，就在當前線程中執行。之後的任務都是開闢新線程。執行異步任務。

創建方式一：使用init:創建操作對象，然後使用addExecutionBlock:添加執行

NSBlockOperation * op1 = [[NSBlockOperation alloc] init];
 [op1 addExecutionBlock:^{
     NSLog(@"1 beign");
     NSLog(@"1--%@",[NSThread currentThread]);
     NSLog(@"1 end");
 }];
 [op addExecutionBlock:^{
     NSLog(@"2 beign");
     NSLog(@"2--%@,currentQueue >>>> %@",[NSThread currentThread],[NSOperationQueue currentQueue]);
     NSLog(@"2 end");
 }];

 [op addExecutionBlock:^{
     NSLog(@"3 beign");
     NSLog(@"3--%@,currentQueue >>>> %@",[NSThread currentThread],[NSOperationQueue currentQueue]);
     NSLog(@"3 end");
 }];
 [op1 start];

創建方式二：使用blockOperationWithBlock創建操作對象

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
     NSLog(@"1 beign");
     NSLog(@"1--%@,currentQueue >>>> %@",[NSThread currentThread],[NSOperationQueue currentQueue]); // 第一個操作任務，一般不會開闢新線程。就在當前線程中執行
     NSLog(@"1 end");
 }];
 // 以下操作任務，會開闢新線程
 [op addExecutionBlock:^{
     NSLog(@"2 beign");
     NSLog(@"2--%@,currentQueue >>>> %@",[NSThread currentThread],[NSOperationQueue currentQueue]);
     NSLog(@"2 end");
 }];

 [op addExecutionBlock:^{
     NSLog(@"3 beign");
     NSLog(@"3--%@,currentQueue >>>> %@",[NSThread currentThread],[NSOperationQueue currentQueue]);
     NSLog(@"3 end");
 }];

 [op start];

3. NSOperationQueue

3.1. 將操作對象添加到隊列中

NSOperationQueue *queue = [[NSOperationQueue alloc] init];
NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
   NSLog(@"1 beign");
   NSLog(@"1--%@",[NSThread currentThread]);
   NSLog(@"1 end");
}];
[queue addOperation:blockOp];

3.2. 添加依賴

直接使用start啓動一個操作對象而非將操作對象添加到NSOperationQueue對象中是沒有意義的。因爲當給操作對象發送start消息後，啓動操作，如果線程未阻塞會立即執行該任務。所以就沒有所謂的執行順序。只有將操作對象添加到NSOperationQueue對象中，在隊列調度的時候，可以按照依賴、優先級等因素順序的調度任務。

注意：一定要在添加線程對象NSOperationQueue之前，進行依賴設置。否則依賴將無法達到預期效果。

a. 通隊列之間的依賴

// 創建隊列
 NSOperationQueue *queue = [[NSOperationQueue alloc] init];
 // 創建操作
 NSInvocationOperation *invocationOp = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOpSel:) object:@"invocationOp--arg"];

 NSInvocationOperation *invocationOp2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOp2Sel:) object:@"invocationOp2--arg"];
 // 設置依賴，操作invocationOp2的任務執行完，纔會執行操作invocationOp的任務。
 [invocationOp addDependency:invocationOp2];
 // 執行
 [queue addOperation:invocationOp];
 [queue addOperation:invocationOp2];

b. 不同隊列間的依賴

// 創建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 創建操作
NSBlockOperation *block1Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block1Op -- begin");
    [NSThread sleepForTimeInterval:3]; // 模擬耗時操作
    NSLog(@"block1Op -- end");
}];
NSBlockOperation *block2Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block2Op -- begin");
    [NSThread sleepForTimeInterval:4]; // 模擬耗時操作
    NSLog(@"block2Op -- end");
}];

// 創建隊列
NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
// 創建操作
NSBlockOperation *block3Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block3Op -- begin");
    [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
    NSLog(@"block3Op -- end");
}];
NSBlockOperation *block4Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block4Op -- begin");
    [NSThread sleepForTimeInterval:1]; // 模擬耗時操作
    NSLog(@"block4Op -- end");
}];

// 設置依賴，操作invocationOp2的任務執行完，纔會執行操作invocationOp的任務。
[block1Op addDependency:block3Op];
[block3Op addDependency:block2Op];

// block2Op --> block3Op --> block1Op
// 添加操作到隊列中
[queue addOperation:block1Op];
[queue addOperation:block2Op];
[queue2 addOperation:block3Op];
[queue2 addOperation:block4Op];

從上代碼可以得到block1Op、block2Op、block3Op三個操作的執行順序：block2Op --> block3Op --> block1Op。

// 創建操作
NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"blockOp");
    // 模擬耗時操作
    [NSThread sleepForTimeInterval:3];
}];
NSBlockOperation *block2Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block2Op -- begin");
    // 等blockOp操作對象的任務執行完，才能接着往下執行
    [blockOp waitUntilFinished];
    NSLog(@"block2Op --end");
}];
// 執行
[queue addOperation:blockOp];
[queue addOperation:block2Op];

3.3. 獲取屬性獲取主隊列

NSOperationQueue *queue = [NSOperationQueue mainQueue];

3.4. 獲取屬性獲取當前隊列

NSOperationQueue *queue = [NSOperationQueue currentQueue];

3.5. 進度修改：NSOperationQueue隊列的暫停、繼續和取消。

// 初始化隊列
- (NSOperationQueue *)manualQueue{
    if (!_manualQueue) {
         _manualQueue = [NSOperationQueue new];
        _manualQueue.maxConcurrentOperationCount = 2;
    }
    return _manualQueue;
}

NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1--start");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"1--end");
    }];

    NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2--start");
        [NSThread sleepForTimeInterval:1];
        NSLog(@"2--end");
    }];

    NSBlockOperation *blockOperation3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3--start");
        [NSThread sleepForTimeInterval:4];
        NSLog(@"3--end");
    }];

    NSBlockOperation *blockOperation4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"4--start");
        [NSThread sleepForTimeInterval:3];
        NSLog(@"4--end");
    }];


    [self.manualQueue addOperation:blockOperation1];
    [self.manualQueue addOperation:blockOperation2];
    [self.manualQueue addOperation:blockOperation3];
    [self.manualQueue addOperation:blockOperation4];

a. 暫停

如果任務正在執行將不會受到影響。因爲任務已經被隊列調度到一個線程上並執行。當NSOperationQueue對象屬性suspended設置爲YES，是隊列停止了對任務調度。對那些還在線程中的操作有影響的。

self.manualQueue.suspended = YES;

b. 繼續

隊列將積極啓動隊列中已準備執行的操作。

self.manualQueue.suspended = NO;

c. 取消

對於隊列中的操作，只有操作標記爲已結束才能被隊列移除。

在隊列中未被調度的操作，會調用start方法執行操作，以便操作對象處理取消事件。然後標記這些操作對象爲已結束。
對於正在線程中執行其任務的操作對象，正在執行的任務會繼續執行，該操作對象會被標記經結束。

[self.manualQueue cancelAllOperations];

3.6. 操作完成

a. 監聽操作完成

可以在操作執行完成後，添加額外的內容。使用屬性completionBlock，可以爲NSOperation對象的任務完成後添加額外的操作。但是不可在completionBlock中追加任務，因爲操作(operation)已經啓動執行或者結束後不可以添加block任務。

NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
  // 添加的任務
}];
blockOperation1.completionBlock = ^{
  // 添加額外的內容
};
[blockOperation1 start];

b. 監聽操作完成
當執行到某個操作對象發送了一個消息waitUntilFinished:消息。當前線程會被阻塞，之前發送消息的操作對象的任務執行完畢。當前線程纔會被喚起，進入準備狀態，開始執行相應的任務。

// 創建隊列
 NSOperationQueue *queue = [[NSOperationQueue alloc] init];
 // 創建操作
 NSBlockOperation *blockOp = [NSBlockOperation blockOperationWithBlock:^{
     [NSThread sleepForTimeInterval:3]; // 模擬耗時操作
 }];
 NSBlockOperation *block2Op = [NSBlockOperation blockOperationWithBlock:^{
     NSLog(@"block2Op -- begin");
     [blockOp waitUntilFinished]; // 等blockOp操作對象的任務執行完，才能接着往下執行
     NSLog(@"block2Op --end");
 }];
 // 執行
 [queue addOperation:blockOp];
 [queue addOperation:block2Op];

3.7. 最大併發量

NSOperationQueue是併發隊列，maxConcurrentOperationCount表示最大的併發數。
當maxConcurrentOperationCount是1時，雖然NSOperationQueue對象是默認併發的調度NSOperation對象，但實際上，此時，NSOperationQueue對象是串行隊列。但是和GCD串行不同的是，依賴和優先級因素會影響NSOperationQueue對象調度任務的順序。添加NSOperation對象的順序不一定是調度的順序。

// 創建隊列
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
// 創建操作
NSBlockOperation *block1Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block1Op -- begin");
    [NSThread sleepForTimeInterval:3]; // 模擬耗時操作
    NSLog(@"block1Op -- end");
}];
NSBlockOperation *block2Op = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"block2Op -- begin");
    [NSThread sleepForTimeInterval:4]; // 模擬耗時操作
    NSLog(@"block2Op -- end");
}];
queue.maxConcurrentOperationCount = 1; // 最大併發個數
[block1Op addDependency:block2Op];// 添加依賴
//    block2Op.queuePriority  = NSOperationQueuePriorityHigh ;
[queue addOperation:block1Op];
[queue addOperation:block2Op];

五、自定義NSOperation子類

我們可以定義串行和併發的2種類型的NSOperation子類。

使用

實現例子如下：
非併發的情況下需要重寫main方法，並且最好添加一個init方法用於初始化數據。

+ (instancetype)downloaderOperationWithURLPath:(NSString *)urlPath completeBlock:(CompleteBlock)completeBlock{
    WNNoCurrentOPration *op = [[WNNoCurrentOPration alloc] init];
    op.urlPath = urlPath;
    op.completeBlock  = completeBlock;
    return op;
}
// main一般只適合自定義非併發的,在裏面實現想執行的任務
- (void)main{
    // 是異步的話 就會導致訪問不到當前的釋放池
    @autoreleasepool {
        NSLog(@"%s",__func__);
        // 當處於取消操作，不執行任務功能
        if (self.isCancelled) return;
        // 下載圖片的耗時操作
        NSURL *url = [NSURL URLWithString:self.urlPath];
        NSData *data = [NSData dataWithContentsOfURL:url];
        NSLog(@"已下載 %@",[NSThread currentThread]);
        UIImage *image = [UIImage imageWithData:data];
        // 主線程回調，完成操作後通知調用方完成回調
        dispatch_async(dispatch_get_main_queue(), ^{
            if (self.completeBlock != nil) {
                self.completeBlock(image);

            }
        });
    }
}

六、GCD VS NSOperation

GCD是蘋果公司爲多核的並行運算提出的解決方案，會自動利用更多的CPU內核(比如雙核、四核)，而NSOperation是基於GCD的面向對象的封裝，擁有GCD的特性。GCD是將任務(block)添加到隊列(串行/並行/全局/主隊列),並且以同步/異步的方式執行任務的函數，而NSOperation將操作(一般是異步的任務)添加到隊列(一般是併發隊列),就會執行指定操作的函數。

相對於NSThread或者是跨平臺的pthread而言，GCD和NSOperation都是自動管理線程的生命週期，開發者只要專注於具體任務邏輯,不需要編寫任何線程管理相關的代碼。

GCD提供了一些NSOperation不具備的功能：延遲執行、一次性執行、調度組；NSOperation裏提供了一些方便的操作：最大併發數、隊列的暫定/繼續、取消所有的操作、指定操作之間的依賴關係(GCD可以用同步實現功能)；

GCD是無法控制線程的最大併發數的，而NSOperation可以設置最大併發數，可以靈活的根據需要限制線程的個數。因爲開闢線程需要消耗必要的資源。

何時使用GCD:
調度隊列(Dispatch queues)、分組(groups)、信號量(semaphores)、柵欄(barriers)組成了一組基本的併發原語。對於一次性執行，或者簡單地加快現有方法的速度，使用輕量級的GCD分派(dispatch)比使用NSOperation更方便。

何時使用NSOperation:
在特定隊列優先級和服務質量(用於表示工作對系統的性質和重要性)下，可以用一系列依賴來調度NSOperation對象。與在GCD隊列上調度的block不同，NSOperation可以被取消和查詢其操作狀態。通過子類化，NSOperation可以關聯執行結果，以供之後參考。

注意：NSOperation和GCD不是互斥的。

七、隊列VS線程VS任務

從思維導圖瞭解整個概況。

1. 隊列(queue)

隊列是先進先出特徵數據結構。並且隊列只是負責任務的調度，而不負責任務的執行。。
按照任務的調度方式可以分爲串行隊列和併發隊列。特點總結如下：

串行隊列
- 一個接一個的調度任務
- 無論隊列中所指定的執行任務是同步還是異步，都會等待前一個任務執行完成後，再調度後面的任務。
併發隊列
- 可以同時調度多個任務。
- 如果當前調度的任務是同步執行的，會等待任務執行完成後，再調度後續的任務。
- 如果當前調度的任務是異步執行的，同時底層線程池有可用的線程資源，會再新的線程調度後續任務的執行。

我們知道系統提供了2個隊列：主隊列和全局併發隊列兩種隊列。我們還可以自己創建隊列。

主隊列
- 特點
  - 添加到主隊列中的任務，都會在主線程中執行。
  - 專門用來在主線程上調度任務的隊列。
  - 在主線程空閒時纔會調度隊列中的任務在主線程執行。
  - 不會開啓線程。
  - 串行。
- 獲取
  - 會隨着程序啓動一起創建。
  - 主隊列只需要獲取不用創建。
  - 主隊列是負責在主線程調度任務的。
全局隊列
- 本質是一個併發隊列，由系統提供，方便編程，可以不用創建就直接使用。
- 全局隊列是所有應用程序共享的
- GCD的一種隊列
- 全局隊列沒有名字，但是併發隊列有名字。有名字可以便於查看系統日誌
自定義隊列
- 有2種方式：串行、併發。
- 添加到自定義隊列中的任務，都會自動放在子線程中執行。

2. 線程(thread)

開闢線程具有一定的資源開銷，iOS系統下主要成本包括：內核數據結構（大約1KB）、棧空間（子線程512KB、主線程1MB，也可以使用-setStackSize:設置，但必須是4K的倍數，而且最小是16K），創建線程大約需要90毫秒
對於單核CPU，同一時間CPU只能處理1條線程，即只有1條線程在執行，多線程併發（同時）執行，其實是CPU快速地在多條線程之間調度（切換），如果CPU調度線程的時間足夠快，就造成了多線程併發執行的假象。
線程是CPU調度和分派且能獨立運行基本單位。
線程執行任務，實際做事的功能單元。
異步：開闢新線程。

3. 任務(task)

一定要分清隊列、線程和任務這三者的關係：隊列調度任務，將任務添加對應的線程上，然後任務是在線程中執行。
任務的執行分爲同步和異步。

同步
- 當前任務未完成，不會執行下個任務
- 不具備開闢新線程能力
異步
- 當前任務未完成，同樣可以執行下一個任務
- 具備開闢新線程能力，但是不一定會開闢線程。開闢線程需要CPU等資源，而系統資源有限。不可能開闢無限個線程。

多線程之NSOperation的進階使用和探討

一、簡介

二、知識概括

1. NSOperation

2. NSOperationQueue

3.依賴

4.線程安全

5.cancel方法

6.狀態屬性

7.操作完成

8.執行順序

9.服務質量

三、相關類介紹

概觀

操作依賴

兼容KVO的屬性

多核注意事項

異步操作 VS 同步操作

子類化註釋

方法的重載

維護操作對象狀態

響應取消命令

屬性和方法

概觀

方法屬性

概觀

方法屬性

概觀

確定執行順序

取消操作

KVO兼容屬性

線程安全

屬性&方法

四、使用

1. NSInvocationOperation

2. NSBlockOperation

3. NSOperationQueue

五、自定義NSOperation子類

相關概念

使用

六、GCD VS NSOperation

七、隊列VS線程VS任務

1. 隊列(queue)

2. 線程(thread)

3. 任務(task)

推薦博客