NSOperation的進階使用和簡單探討

雅之道法自然發表於2018-11-24

NSOperation的進階使用和簡單探討
本文將會從多個方面探討NSOperation類和NSOperationQueue類的相關內容
NSOperation的進階使用和簡單探討

一、簡介

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

二、知識概括

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

NSOperation的進階使用和簡單探討

NSOperation和NSOperationQueue是基於GCD的更高一層的封裝，分別對應GCD的任務和佇列，完全地物件導向。可以通過start方法直接啟動NSOperation子類物件，並且預設同步執行任務，將NSOperation子類物件新增到NSOperationQueue中，該佇列預設併發的排程任務。

開啟操作有二種方式，一是通過start方法直接啟動操作，該操作預設同步執行，二是將操作新增到NSOperationQueue中，然後由系統從佇列中獲取操作然後新增到一個新執行緒中執行，這些操作預設併發執行。

具體實現如下：

方式一：直接由NSOperation子類物件啟動。 首先將需要執行的操作封裝到NSOperation子類物件中，然後該物件呼叫Start方法。

方式二：當新增到NSOperationQueue物件中，由該佇列物件啟動操作。

  1. 將需要執行的操作封裝到NSOperation子類物件中
  2. 將該物件新增到NSOperationQueue中
  3. 系統將NSOperation子類物件從NSOperationQueue中取出
  4. 將取出的操作放到一個新執行緒中執行

使用佇列來執行操作，分為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. 任務數為1時，即使用blockOperationWithBlock:方法或者init:與addExecutionBlock:二個方法結合的方式建立的唯一一個任務時，不會開闢新執行緒，直接在當前執行緒同步執行任務。
  2. 任務數大於1時，使用blockOperationWithBlock:方法或者init:與addExecutionBlock:二個方法結合的方式建立的一個任務A，不會開闢執行緒，直接在當前執行緒同步執行任務。而NSBlockOperation物件使用addExecutionBlock:方法新增的其他任務會開闢新執行緒，非同步執行任務。
  3. 將操作放到一個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決定的。

相關概念：

  1. 併發數: NSOperationQueue佇列裡同時能排程的NSOperation物件數。
  2. 最大併發數: 同一時間最多能排程的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:方法移除依賴。

NSOperation的進階使用和簡單探討

如圖，箭頭方向就是依賴的物件，從圖中可知，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. 取消

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

  1. 在佇列中未被排程的操作，會呼叫start方法執行操作，以便操作物件處理取消事件。然後標記這些操作物件為已結束。
  2. 對於正線上程中執行其任務的操作物件，正在執行的任務會繼續執行，該操作物件會被標記經結束。
[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子類

NSOperation的進階使用和簡單探討
我們可以定義序列和併發的2種型別的NSOperation子類。

相關概念

  1. 序列(非併發)的情況
  • 常見使用場景：和網路相關，比如圖片下載
  • 使用步驟
    • 實現init方法，初始化操作物件以及一些其他物件
    • 重寫main方法，在裡面實現想要執行的方法
    • 在main方法中，建立自動釋放池，因為如果是非同步操作，無法訪問主執行緒的自動釋放池
    • 經常通過cancelled屬性檢查方法是否取消，並且對取消的做出響應
  • 響應取消事件
    • 取消事件可以在任何時間發生
    • 定期呼叫物件的isCancelled方法，如果返回“YES”，則立即返回，不再執行任務 isCancelled方法本身非常輕量級，可以頻繁呼叫，沒有任何顯著的效能損失
  • 位置呼叫
    • 在執行任何實際工作之前
    • 在迴圈的每次迭代期間或者如果每次迭代相對較長，較頻繁時至少呼叫一次
    • 在程式碼中相對容易中止操作的任何點
  1. 併發
  • 重寫方法
    • 必需重寫四個方法：start、asynchronous、executing、finished
    • start(必需)：所有併發操作必須重寫此方法，並需要使用自定義的實現替換預設行為。任何時候都不能呼叫父類的start方法。 即不可使用super。重寫的start方法負責以非同步的方式啟動一個操作，無論是開啟一個執行緒還是呼叫非同步函式，都可以在start方法中進行。注意在開始操作之前，應該在start中更新操作的執行狀態，因為要給KVO的鍵路徑傳送當前操作的執行狀態，方便檢視操作狀態。
    • main(可選)：在這個方法中，放置執行給定任務所需的程式碼。應該定義一個自定義初始化方法，以便更容易建立自定義類的例項。當如果定義了自定義的getter和setter方法，必須確保這些方法可以從多個執行緒安全地呼叫。雖然可以在start方法中執行任務，但使用此方法實現任務可以更清晰地分離設定和任務程式碼,即在start方法中呼叫mian方法。注意:要定義獨立的自動釋放池與別的執行緒區分開。
    • isFinished(必需)：表示是否已完成。需要實現KVO通知機制。
    • isAsynchronous(必需)：預設返回 NO ，表示非併發執行。併發執行需要自定義並且返回 YES。後面會根據這個返回值來決定是否併發。
    • isExecuting(必需)：表示是否執行中，需要實現KVO通知機制。

注意：自己建立自動釋放池，非同步操作無法訪問主執行緒的自動釋放池

使用

實現例子如下： 非併發的情況下需要重寫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

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任務

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

NSOperation的進階使用和簡單探討

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等資源，而系統資源有限。不可能開闢無限個執行緒。

推薦部落格

相關文章