NSOperation的進階使用和簡單探討

時間 2019-11-06

標籤 nsoperation 進階使用簡單探討简体版

原文原文鏈接

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

1、簡介

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

2、知識歸納

從NSOperation的思惟導圖瞭解的這個類相關的總體的知識點： objective-c

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種：app

系統實現的具體子類：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 更加智能的分配硬件資源，以便於提升執行效率和控制電量。

3、相關類介紹

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;
複製代碼

4、使用

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];
複製代碼

5、自定義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);

            }
        });
    }
}
複製代碼

6、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不是互斥的。

7、隊列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、簡介

2、知識歸納

1. NSOperation

2. NSOperationQueue

3.依賴

4.線程安全

5.cancel方法

6.狀態屬性

7.操做完成

8.執行順序

9.服務質量

3、相關類介紹

NSOperation

概觀

操做依賴

兼容KVO的屬性

多核注意事項

異步操做 VS 同步操做

子類化註釋

方法的重載

維護操做對象狀態

響應取消命令

屬性和方法

NSBlockOperation

概觀

方法屬性

NSInvocationOperation

概觀

方法屬性

NSOperationQueue

概觀

肯定執行順序

取消操做

KVO兼容屬性

線程安全

屬性&方法

4、使用

1. NSInvocationOperation

2. NSBlockOperation

3. NSOperationQueue

5、自定義NSOperation子類

相關概念

使用

6、GCD VS NSOperation

7、隊列VS線程VS任務

1. 隊列(queue)

2. 線程(thread)

3. 任務(task)

推薦博客