1. NSOperation、NSOperationQueue 簡介

轉(zhuǎn)載：行走少年郎

NSOperation、NSOperationQueue 是蘋果提供給我們的一套多線程解決方案。實際上 NSOperation、NSOperationQueue 是基于 GCD 更高一層的封裝，完全面向?qū)ο?。但是?GCD 更簡單易用、代碼可讀性也更高。

為什么要使用 NSOperation、NSOperationQueue？

可添加完成的代碼塊，在操作完成后執(zhí)行。
添加操作之間的依賴關(guān)系，方便的控制執(zhí)行順序。
設(shè)定操作執(zhí)行的優(yōu)先級。
可以很方便的取消一個操作的執(zhí)行。
使用 KVO 觀察對操作執(zhí)行狀態(tài)的更改：isExecuteing、isFinished、isCancelled。

2. NSOperation、NSOperationQueue 操作和操作隊列

既然是基于 GCD 的更高一層的封裝。那么，GCD 中的一些概念同樣適用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有類似的任務(wù)（操作）和隊列（操作隊列）的概念。

操作（Operation）：
- 執(zhí)行操作的意思，換句話說就是你在線程中執(zhí)行的那段代碼。
- 在 GCD 中是放在 block 中的。在 NSOperation 中，我們使用 NSOperation 子類 NSInvocationOperation、NSBlockOperation，或者自定義子類來封裝操作。
操作隊列（Operation Queues）：
- 這里的隊列指操作隊列，即用來存放操作的隊列。不同于 GCD 中的調(diào)度隊列 FIFO（先進(jìn)先出）的原則。NSOperationQueue 對于添加到隊列中的操作，首先進(jìn)入準(zhǔn)備就緒的狀態(tài)（就緒狀態(tài)取決于操作之間的依賴關(guān)系），然后進(jìn)入就緒狀態(tài)的操作的開始執(zhí)行順序（非結(jié)束執(zhí)行順序）由操作之間相對的優(yōu)先級決定（優(yōu)先級是操作對象自身的屬性）。
- 操作隊列通過設(shè)置最大并發(fā)操作數(shù)（maxConcurrentOperationCount）來控制并發(fā)、串行。
- NSOperationQueue 為我們提供了兩種不同類型的隊列：主隊列和自定義隊列。主隊列運行在主線程之上，而自定義隊列在后臺執(zhí)行。

3. NSOperation、NSOperationQueue 使用步驟

NSOperation 需要配合 NSOperationQueue 來實現(xiàn)多線程。因為默認(rèn)情況下，NSOperation 單獨使用時系統(tǒng)同步執(zhí)行操作，配合 NSOperationQueue 我們能更好的實現(xiàn)異步執(zhí)行。

NSOperation 實現(xiàn)多線程的使用步驟分為三步：

創(chuàng)建操作：先將需要執(zhí)行的操作封裝到一個 NSOperation 對象中。
創(chuàng)建隊列：創(chuàng)建 NSOperationQueue 對象。
將操作加入到隊列中：將 NSOperation 對象添加到 NSOperationQueue 對象中。

之后呢，系統(tǒng)就會自動將 NSOperationQueue 中的 NSOperation 取出來，在新線程中執(zhí)行操作。

下面我們來學(xué)習(xí)下 NSOperation 和 NSOperationQueue 的基本使用。

4. NSOperation 和 NSOperationQueue 基本使用

4.1 創(chuàng)建操作

NSOperation 是個抽象類，不能用來封裝操作。我們只有使用它的子類來封裝操作。我們有三種方式來封裝操作。

使用子類 NSInvocationOperation
使用子類 NSBlockOperation
自定義繼承自 NSOperation 的子類，通過實現(xiàn)內(nèi)部相應(yīng)的方法來封裝操作。

在不使用 NSOperationQueue，單獨使用 NSOperation 的情況下系統(tǒng)同步執(zhí)行操作，下面我們學(xué)習(xí)以下操作的三種創(chuàng)建方式。

4.1.1 使用子類 `NSInvocationOperation`

/**
 * 使用子類 NSInvocationOperation
 */
- (void)useInvocationOperation {

    // 1.創(chuàng)建 NSInvocationOperation 對象
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];

    // 2.調(diào)用 start 方法開始執(zhí)行操作
    [op start];
}

/**
 * 任務(wù)1
 */
- (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
        NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
    }
}

輸出結(jié)果：

可以看到：在沒有使用 NSOperationQueue、在主線程中單獨使用使用子類 NSInvocationOperation 執(zhí)行一個操作的情況下，操作是在當(dāng)前線程執(zhí)行的，并沒有開啟新線程。

如果在其他線程中執(zhí)行操作，則打印結(jié)果為其他線程。

// 在其他線程使用子類 NSInvocationOperation
[NSThread detachNewThreadSelector:@selector(useInvocationOperation) toTarget:self withObject:nil];

輸出結(jié)果：

image

可以看到：在其他線程中單獨使用子類 NSInvocationOperation，操作是在當(dāng)前調(diào)用的其他線程執(zhí)行的，并沒有開啟新線程。

下邊再來看看 NSBlockOperation。

4.1.2 使用子類 `NSBlockOperation`

/**
 * 使用子類 NSBlockOperation
 */
- (void)useBlockOperation {

    // 1.創(chuàng)建 NSBlockOperation 對象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];

    // 2.調(diào)用 start 方法開始執(zhí)行操作
    [op start];
}

輸出結(jié)果：

image

可以看到：在沒有使用 NSOperationQueue、在主線程中單獨使用 NSBlockOperation 執(zhí)行一個操作的情況下，操作是在當(dāng)前線程執(zhí)行的，并沒有開啟新線程。

注意：和上邊 NSInvocationOperation 使用一樣。因為代碼是在主線程中調(diào)用的，所以打印結(jié)果為主線程。如果在其他線程中執(zhí)行操作，則打印結(jié)果為其他線程。

但是，NSBlockOperation 還提供了一個方法 addExecutionBlock:，通過 addExecutionBlock: 就可以為 NSBlockOperation 添加額外的操作。這些操作（包括 blockOperationWithBlock 中的操作）可以在不同的線程中同時（并發(fā)）執(zhí)行。只有當(dāng)所有相關(guān)的操作已經(jīng)完成執(zhí)行時，才視為完成。

如果添加的操作多的話，blockOperationWithBlock: 中的操作也可能會在其他線程（非當(dāng)前線程）中執(zhí)行，這是由系統(tǒng)決定的，并不是說添加到 blockOperationWithBlock: 中的操作一定會在當(dāng)前線程中執(zhí)行。（可以使用 addExecutionBlock: 多添加幾個操作試試）。

/**
 * 使用子類 NSBlockOperation
 * 調(diào)用方法 AddExecutionBlock:
 */
- (void)useBlockOperationAddExecutionBlock {

    // 1.創(chuàng)建 NSBlockOperation 對象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];

    // 2.添加額外的操作
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"5---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"6---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"7---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"8---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];

    // 3.調(diào)用 start 方法開始執(zhí)行操作
    [op start];
}

輸出結(jié)果：

image

可以看出：使用子類 NSBlockOperation，并調(diào)用方法 AddExecutionBlock: 的情況下，blockOperationWithBlock:方法中的操作和 addExecutionBlock: 中的操作是在不同的線程中異步執(zhí)行的。而且，這次執(zhí)行結(jié)果中 blockOperationWithBlock:方法中的操作也不是在當(dāng)前線程（主線程）中執(zhí)行的。從而印證了blockOperationWithBlock: 中的操作也可能會在其他線程（非當(dāng)前線程）中執(zhí)行。

一般情況下，如果一個 NSBlockOperation 對象封裝了多個操作。NSBlockOperation 是否開啟新線程，取決于操作的個數(shù)。如果添加的操作的個數(shù)多，就會自動開啟新線程。當(dāng)然開啟的線程數(shù)是由系統(tǒng)來決定的。

4.1.3 使用自定義繼承自 NSOperation 的子類

如果使用子類 NSInvocationOperation、NSBlockOperation 不能滿足日常需求，我們可以使用自定義繼承自 NSOperation 的子類。可以通過重寫 main 或者 start 方法來定義自己的 NSOperation 對象。重寫main方法比較簡單，我們不需要管理操作的狀態(tài)屬性 isExecuting 和 isFinished。當(dāng) main 執(zhí)行完返回的時候，這個操作就結(jié)束了。

先定義一個繼承自 NSOperation 的子類，重寫main方法。

// YSCOperation.h 文件
#import <Foundation/Foundation.h>

@interface YSCOperation : NSOperation

@end

// YSCOperation.m 文件
#import "YSCOperation.h"

@implementation YSCOperation

- (void)main {
    if (!self.isCancelled) {
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"1---%@", [NSThread currentThread]);
        }
    }
}

@end

然后使用的時候?qū)腩^文件YSCOperation.h。

/**
 * 使用自定義繼承自 NSOperation 的子類
 */
- (void)useCustomOperation {
    // 1.創(chuàng)建 YSCOperation 對象
    YSCOperation *op = [[YSCOperation alloc] init];
    // 2.調(diào)用 start 方法開始執(zhí)行操作
    [op start];
}

輸出結(jié)果：

image

可以看出：在沒有使用 NSOperationQueue、在主線程單獨使用自定義繼承自 NSOperation 的子類的情況下，是在主線程執(zhí)行操作，并沒有開啟新線程。

下邊我們來講講 NSOperationQueue 的創(chuàng)建。

4.2 創(chuàng)建隊列

NSOperationQueue 一共有兩種隊列：主隊列、自定義隊列。其中自定義隊列同時包含了串行、并發(fā)功能。下邊是主隊列、自定義隊列的基本創(chuàng)建方法和特點。

主隊列
- 凡是添加到主隊列中的操作，都會放到主線程中執(zhí)行（注：不包括操作使用addExecutionBlock:添加的額外操作，額外操作可能在其他線程執(zhí)行，感謝指正）。

// 主隊列獲取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];

自定義隊列（非主隊列）
- 添加到這種隊列中的操作，就會自動放到子線程中執(zhí)行。
- 同時包含了：串行、并發(fā)功能。

// 自定義隊列創(chuàng)建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

4.3 將操作加入到隊列中

上邊我們說到 NSOperation 需要配合 NSOperationQueue 來實現(xiàn)多線程。

那么我們需要將創(chuàng)建好的操作加入到隊列中去?？偣灿袃煞N方法：

- (void)addOperation:(NSOperation *)op;
- 需要先創(chuàng)建操作，再將創(chuàng)建好的操作加入到創(chuàng)建好的隊列中去。

/**
 * 使用 addOperation: 將操作加入到操作隊列中
 */
- (void)addOperationToQueue {

    // 1.創(chuàng)建隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.創(chuàng)建操作
    // 使用 NSInvocationOperation 創(chuàng)建操作1
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];

    // 使用 NSInvocationOperation 創(chuàng)建操作2
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];

    // 使用 NSBlockOperation 創(chuàng)建操作3
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [op3 addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];

    // 3.使用 addOperation: 添加所有操作到隊列中
    [queue addOperation:op1]; // [op1 start]
    [queue addOperation:op2]; // [op2 start]
    [queue addOperation:op3]; // [op3 start]
}

輸出結(jié)果：

image

可以看出：使用 NSOperation 子類創(chuàng)建操作，并使用 addOperation: 將操作加入到操作隊列后能夠開啟新線程，進(jìn)行并發(fā)執(zhí)行。

- (void)addOperationWithBlock:(void (^)(void))block;
- 無需先創(chuàng)建操作，在 block 中添加操作，直接將包含操作的 block 加入到隊列中。

/**
 * 使用 addOperationWithBlock: 將操作加入到操作隊列中
 */

- (void)addOperationWithBlockToQueue {
    // 1.創(chuàng)建隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.使用 addOperationWithBlock: 添加操作到隊列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
}

輸出結(jié)果：

image

可以看出：使用 addOperationWithBlock: 將操作加入到操作隊列后能夠開啟新線程，進(jìn)行并發(fā)執(zhí)行。

5. NSOperationQueue 控制串行執(zhí)行、并發(fā)執(zhí)行

之前我們說過，NSOperationQueue 創(chuàng)建的自定義隊列同時具有串行、并發(fā)功能，上邊我們演示了并發(fā)功能，那么他的串行功能是如何實現(xiàn)的？

這里有個關(guān)鍵屬性 maxConcurrentOperationCount，叫做最大并發(fā)操作數(shù)。用來控制一個特定隊列中可以有多少個操作同時參與并發(fā)執(zhí)行。

注意：這里 maxConcurrentOperationCount 控制的不是并發(fā)線程的數(shù)量，而是一個隊列中同時能并發(fā)執(zhí)行的最大操作數(shù)。而且一個操作也并非只能在一個線程中運行。

最大并發(fā)操作數(shù)：maxConcurrentOperationCount
- maxConcurrentOperationCount 默認(rèn)情況下為-1，表示不進(jìn)行限制，可進(jìn)行并發(fā)執(zhí)行。
- maxConcurrentOperationCount 為1時，隊列為串行隊列。只能串行執(zhí)行。
- maxConcurrentOperationCount 大于1時，隊列為并發(fā)隊列。操作并發(fā)執(zhí)行，當(dāng)然這個值不應(yīng)超過系統(tǒng)限制，即使自己設(shè)置一個很大的值，系統(tǒng)也會自動調(diào)整為 min{自己設(shè)定的值，系統(tǒng)設(shè)定的默認(rèn)最大值}。

/**
 * 設(shè)置 MaxConcurrentOperationCount（最大并發(fā)操作數(shù)）
 */
- (void)setMaxConcurrentOperationCount {

    // 1.創(chuàng)建隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.設(shè)置最大并發(fā)操作數(shù)
    queue.maxConcurrentOperationCount = 1; // 串行隊列
// queue.maxConcurrentOperationCount = 2; // 并發(fā)隊列
// queue.maxConcurrentOperationCount = 8; // 并發(fā)隊列

    // 3.添加操作
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
}

最大并發(fā)操作數(shù)為1 輸出結(jié)果：

image
最大并發(fā)操作數(shù)為2 輸出結(jié)果：

image
可以看出：當(dāng)最大并發(fā)操作數(shù)為1時，操作是按順序串行執(zhí)行的，并且一個操作完成之后，下一個操作才開始執(zhí)行。當(dāng)最大操作并發(fā)數(shù)為2時，操作是并發(fā)執(zhí)行的，可以同時執(zhí)行兩個操作。而開啟線程數(shù)量是由系統(tǒng)決定的，不需要我們來管理。

這樣看來，是不是比 GCD 還要簡單了許多？

6. NSOperation 操作依賴

NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之間的依賴關(guān)系。通過操作依賴，我們可以很方便的控制操作之間的執(zhí)行先后順序。NSOperation 提供了3個接口供我們管理和查看依賴。

- (void)addDependency:(NSOperation *)op; 添加依賴，使當(dāng)前操作依賴于操作 op 的完成。
- (void)removeDependency:(NSOperation *)op; 移除依賴，取消當(dāng)前操作對操作 op 的依賴。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在當(dāng)前操作開始執(zhí)行之前完成執(zhí)行的所有操作對象數(shù)組。

當(dāng)然，我們經(jīng)常用到的還是添加依賴操作?，F(xiàn)在考慮這樣的需求，比如說有 A、B 兩個操作，其中 A 執(zhí)行完操作，B 才能執(zhí)行操作。

如果使用依賴來處理的話，那么就需要讓操作 B 依賴于操作 A。具體代碼如下：

/**
 * 操作依賴
 * 使用方法：addDependency:
 */
- (void)addDependency {

    // 1.創(chuàng)建隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.創(chuàng)建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }
    }];

    // 3.添加依賴
    [op2 addDependency:op1]; // 讓op2 依賴于 op1，則先執(zhí)行op1，在執(zhí)行op2

    // 4.添加操作到隊列中
    [queue addOperation:op1];
    [queue addOperation:op2];
}

輸出結(jié)果：

image

可以看到：通過添加操作依賴，無論運行幾次，其結(jié)果都是 op1 先執(zhí)行，op2 后執(zhí)行。

7. NSOperation 優(yōu)先級

NSOperation 提供了queuePriority（優(yōu)先級）屬性，queuePriority屬性適用于同一操作隊列中的操作，不適用于不同操作隊列中的操作。默認(rèn)情況下，所有新創(chuàng)建的操作對象優(yōu)先級都是NSOperationQueuePriorityNormal。但是我們可以通過setQueuePriority:方法來改變當(dāng)前操作在同一隊列中的執(zhí)行優(yōu)先級。

// 優(yōu)先級的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
};

上邊我們說過：對于添加到隊列中的操作，首先進(jìn)入準(zhǔn)備就緒的狀態(tài)（就緒狀態(tài)取決于操作之間的依賴關(guān)系），然后進(jìn)入就緒狀態(tài)的操作的開始執(zhí)行順序（非結(jié)束執(zhí)行順序）由操作之間相對的優(yōu)先級決定（優(yōu)先級是操作對象自身的屬性）。

那么，什么樣的操作才是進(jìn)入就緒狀態(tài)的操作呢？

當(dāng)一個操作的所有依賴都已經(jīng)完成時，操作對象通常會進(jìn)入準(zhǔn)備就緒狀態(tài)，等待執(zhí)行。

舉個例子，現(xiàn)在有4個優(yōu)先級都是 NSOperationQueuePriorityNormal（默認(rèn)級別）的操作：op1，op2，op3，op4。其中 op3 依賴于 op2，op2 依賴于 op1，即 op3 -> op2 -> op1?，F(xiàn)在將這4個操作添加到隊列中并發(fā)執(zhí)行。

因為 op1 和 op4 都沒有需要依賴的操作，所以在 op1，op4 執(zhí)行之前，就是處于準(zhǔn)備就緒狀態(tài)的操作。
而 op3 和 op2 都有依賴的操作（op3 依賴于 op2，op2 依賴于 op1），所以 op3 和 op2 都不是準(zhǔn)備就緒狀態(tài)下的操作。

理解了進(jìn)入就緒狀態(tài)的操作，那么我們就理解了queuePriority 屬性的作用對象。

queuePriority 屬性決定了進(jìn)入準(zhǔn)備就緒狀態(tài)下的操作之間的開始執(zhí)行順序。并且，優(yōu)先級不能取代依賴關(guān)系。
如果一個隊列中既包含高優(yōu)先級操作，又包含低優(yōu)先級操作，并且兩個操作都已經(jīng)準(zhǔn)備就緒，那么隊列先執(zhí)行高優(yōu)先級操作。比如上例中，如果 op1 和 op4 是不同優(yōu)先級的操作，那么就會先執(zhí)行優(yōu)先級高的操作。
如果，一個隊列中既包含了準(zhǔn)備就緒狀態(tài)的操作，又包含了未準(zhǔn)備就緒的操作，未準(zhǔn)備就緒的操作優(yōu)先級比準(zhǔn)備就緒的操作優(yōu)先級高。那么，雖然準(zhǔn)備就緒的操作優(yōu)先級低，也會優(yōu)先執(zhí)行。優(yōu)先級不能取代依賴關(guān)系。如果要控制操作間的啟動順序，則必須使用依賴關(guān)系。

8. NSOperation、NSOperationQueue 線程間的通信

在 iOS 開發(fā)過程中，我們一般在主線程里邊進(jìn)行 UI 刷新，例如：點擊、滾動、拖拽等事件。我們通常把一些耗時的操作放在其他線程，比如說圖片下載、文件上傳等耗時操作。而當(dāng)我們有時候在其他線程完成了耗時操作時，需要回到主線程，那么就用到了線程之間的通訊。

/**
 * 線程間通信
 */
- (void)communication {

    // 1.創(chuàng)建隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    // 2.添加操作
    [queue addOperationWithBlock:^{
        // 異步進(jìn)行耗時操作
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印當(dāng)前線程
        }

        // 回到主線程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // 進(jìn)行一些 UI 刷新等操作
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:2]; // 模擬耗時操作
                NSLog(@"2---%@", [NSThread currentThread]); // 打印當(dāng)前線程
            }
        }];
    }];
}

輸出結(jié)果：

image

可以看到：通過線程間的通信，先在其他線程中執(zhí)行操作，等操作執(zhí)行完了之后再回到主線程執(zhí)行主線程的相應(yīng)操作。

9. NSOperation、NSOperationQueue 線程同步和線程安全

線程安全：如果你的代碼所在的進(jìn)程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結(jié)果和單線程運行的結(jié)果是一樣的，而且其他的變量的值也和預(yù)期的是一樣的，就是線程安全的。
若每個線程中對全局變量、靜態(tài)變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執(zhí)行寫操作（更改變量），一般都需要考慮線程同步，否則的話就可能影響線程安全。
線程同步：可理解為線程 A 和線程 B 一塊配合，A 執(zhí)行到一定程度時要依靠線程 B 的某個結(jié)果，于是停下來，示意 B 運行；B 依言執(zhí)行，再將結(jié)果給 A；A 再繼續(xù)操作。

舉個簡單例子就是：兩個人在一起聊天。兩個人不能同時說話，避免聽不清(操作沖突)。等一個人說完(一個線程結(jié)束操作)，另一個再說(另一個線程再開始操作)。

下面，我們模擬火車票售賣的方式，實現(xiàn) NSOperation 線程安全和解決線程同步問題。
場景：總共有50張火車票，有兩個售賣火車票的窗口，一個是北京火車票售賣窗口，另一個是上?；疖嚻笔圪u窗口。兩個窗口同時售賣火車票，賣完為止。

9.1 NSOperation、NSOperationQueue 非線程安全

先來看看不考慮線程安全的代碼：

/**
 * 非線程安全：不使用 NSLock
 * 初始化火車票數(shù)量、賣票窗口(非線程安全)、并開始賣票
 */
- (void)initTicketStatusNotSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程

    self.ticketSurplusCount = 50;

    // 1.創(chuàng)建 queue1,queue1 代表北京火車票售賣窗口
    NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
    queue1.maxConcurrentOperationCount = 1;

    // 2.創(chuàng)建 queue2,queue2 代表上?；疖嚻笔圪u窗口
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
    queue2.maxConcurrentOperationCount = 1;

    // 3.創(chuàng)建賣票操作 op1
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketNotSafe];
    }];

    // 4.創(chuàng)建賣票操作 op2
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketNotSafe];
    }];

    // 5.添加操作，開始賣票
    [queue1 addOperation:op1];
    [queue2 addOperation:op2];
}

/**
 * 售賣火車票(非線程安全)
 */
- (void)saleTicketNotSafe {
    while (1) {

        if (self.ticketSurplusCount > 0) {
            //如果還有票，繼續(xù)售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù):%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else {
            NSLog(@"所有火車票均已售完");
            break;
        }
    }
}

輸出結(jié)果：

image

省略一部分結(jié)果圖。。。

image

可以看到：在不考慮線程安全，不使用 NSLock 情況下，得到票數(shù)是錯亂的，這樣顯然不符合我們的需求，所以我們需要考慮線程安全問題。

9.2 NSOperation、NSOperationQueue 線程安全

線程安全解決方案：可以給線程加鎖，在一個線程執(zhí)行該操作的時候，不允許其他線程進(jìn)行操作。iOS 實現(xiàn)線程加鎖有很多種方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各種方式。這里我們使用 NSLock 對象來解決線程同步問題。NSLock 對象可以通過進(jìn)入鎖時調(diào)用 lock 方法，解鎖時調(diào)用 unlock 方法來保證線程安全。

考慮線程安全的代碼：

/**
 * 線程安全：使用 NSLock 加鎖
 * 初始化火車票數(shù)量、賣票窗口(線程安全)、并開始賣票
 */

- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印當(dāng)前線程

    self.ticketSurplusCount = 50;

    self.lock = [[NSLock alloc] init];  // 初始化 NSLock 對象

    // 1.創(chuàng)建 queue1,queue1 代表北京火車票售賣窗口
    NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
    queue1.maxConcurrentOperationCount = 1;

    // 2.創(chuàng)建 queue2,queue2 代表上?；疖嚻笔圪u窗口
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
    queue2.maxConcurrentOperationCount = 1;

    // 3.創(chuàng)建賣票操作 op1
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketSafe];
    }];

    // 4.創(chuàng)建賣票操作 op2
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [self saleTicketSafe];
    }];

    // 5.添加操作，開始賣票
    [queue1 addOperation:op1];
    [queue2 addOperation:op2];
}

/**
 * 售賣火車票(線程安全)
 */
- (void)saleTicketSafe {
    while (1) {

        // 加鎖
        [self.lock lock];

        if (self.ticketSurplusCount > 0) {
            //如果還有票，繼續(xù)售賣
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數(shù):%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }

        // 解鎖
        [self.lock unlock];

        if (self.ticketSurplusCount <= 0) {
            NSLog(@"所有火車票均已售完");
            break;
        }
    }
}

輸出結(jié)果：

image

省略一部分結(jié)果圖。。。

image

可以看出：在考慮了線程安全，使用 NSLock 加鎖、解鎖機制的情況下，得到的票數(shù)是正確的，沒有出現(xiàn)混亂的情況。我們也就解決了多個線程同步的問題。

10. NSOperation、NSOperationQueue 常用屬性和方法歸納

10.1 NSOperation 常用屬性和方法

取消操作方法
- - (void)cancel; 可取消操作，實質(zhì)是標(biāo)記 isCancelled 狀態(tài)。
判斷操作狀態(tài)方法
- - (BOOL)isFinished; 判斷操作是否已經(jīng)結(jié)束。
- - (BOOL)isCancelled; 判斷操作是否已經(jīng)標(biāo)記為取消。
- - (BOOL)isExecuting; 判斷操作是否正在在運行。
- - (BOOL)isReady; 判斷操作是否處于準(zhǔn)備就緒狀態(tài)，這個值和操作的依賴關(guān)系相關(guān)。
操作同步
- - (void)waitUntilFinished; 阻塞當(dāng)前線程，直到該操作結(jié)束?？捎糜诰€程執(zhí)行順序的同步。
- - (void)setCompletionBlock:(void (^)(void))block; completionBlock 會在當(dāng)前操作執(zhí)行完畢時執(zhí)行 completionBlock。
- - (void)addDependency:(NSOperation *)op; 添加依賴，使當(dāng)前操作依賴于操作 op 的完成。
- - (void)removeDependency:(NSOperation *)op; 移除依賴，取消當(dāng)前操作對操作 op 的依賴。
- @property (readonly, copy) NSArray<NSOperation *> *dependencies; 在當(dāng)前操作開始執(zhí)行之前完成執(zhí)行的所有操作對象數(shù)組。

10.2 NSOperationQueue 常用屬性和方法

取消/暫停/恢復(fù)操作
- - (void)cancelAllOperations; 可以取消隊列的所有操作。
- - (BOOL)isSuspended; 判斷隊列是否處于暫停狀態(tài)。 YES 為暫停狀態(tài)，NO 為恢復(fù)狀態(tài)。
- - (void)setSuspended:(BOOL)b; 可設(shè)置操作的暫停和恢復(fù)，YES 代表暫停隊列，NO 代表恢復(fù)隊列。
操作同步
- - (void)waitUntilAllOperationsAreFinished; 阻塞當(dāng)前線程，直到隊列中的操作全部執(zhí)行完畢。
添加/獲取操作`
- - (void)addOperationWithBlock:(void (^)(void))block; 向隊列中添加一個 NSBlockOperation 類型操作對象。
- - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向隊列中添加操作數(shù)組，wait 標(biāo)志是否阻塞當(dāng)前線程直到所有操作結(jié)束
- - (NSArray *)operations; 當(dāng)前在隊列中的操作數(shù)組（某個操作執(zhí)行結(jié)束后會自動從這個數(shù)組清除）。
- - (NSUInteger)operationCount; 當(dāng)前隊列中的操作數(shù)。
獲取隊列
- + (id)currentQueue; 獲取當(dāng)前隊列，如果當(dāng)前線程不是在 NSOperationQueue 上運行則返回 nil。
- + (id)mainQueue; 獲取主隊列。

注意：

這里的暫停和取消（包括操作的取消和隊列的取消）并不代表可以將當(dāng)前的操作立即取消，而是當(dāng)當(dāng)前的操作執(zhí)行完畢之后不再執(zhí)行新的操作。

暫停和取消的區(qū)別就在于：暫停操作之后還可以恢復(fù)操作，繼續(xù)向下執(zhí)行；而取消操作之后，所有的操作就清空了，無法再接著執(zhí)行剩下的操作。

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

NSOperation、NSOperationQueue 簡介

NSOperation、NSOperationQueue 簡介

1. NSOperation、NSOperationQueue 簡介

2. NSOperation、NSOperationQueue 操作和操作隊列

3. NSOperation、NSOperationQueue 使用步驟

4. NSOperation 和 NSOperationQueue 基本使用

4.1 創(chuàng)建操作

4.1.1 使用子類 `NSInvocationOperation`

4.1.2 使用子類 `NSBlockOperation`

4.1.3 使用自定義繼承自 NSOperation 的子類

4.2 創(chuàng)建隊列

4.3 將操作加入到隊列中

5. NSOperationQueue 控制串行執(zhí)行、并發(fā)執(zhí)行

6. NSOperation 操作依賴

7. NSOperation 優(yōu)先級

8. NSOperation、NSOperationQueue 線程間的通信

9. NSOperation、NSOperationQueue 線程同步和線程安全

9.1 NSOperation、NSOperationQueue 非線程安全

9.2 NSOperation、NSOperationQueue 線程安全

10. NSOperation、NSOperationQueue 常用屬性和方法歸納

10.1 NSOperation 常用屬性和方法

10.2 NSOperationQueue 常用屬性和方法

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

NSOperation、NSOperationQueue 簡介

1. NSOperation、NSOperationQueue 簡介

2. NSOperation、NSOperationQueue 操作和操作隊列

3. NSOperation、NSOperationQueue 使用步驟

4. NSOperation 和 NSOperationQueue 基本使用

4.1 創(chuàng)建操作

4.1.1 使用子類 NSInvocationOperation

4.1.2 使用子類 NSBlockOperation

4.1.3 使用自定義繼承自 NSOperation 的子類

4.2 創(chuàng)建隊列

4.3 將操作加入到隊列中

5. NSOperationQueue 控制串行執(zhí)行、并發(fā)執(zhí)行

6. NSOperation 操作依賴

7. NSOperation 優(yōu)先級

8. NSOperation、NSOperationQueue 線程間的通信

9. NSOperation、NSOperationQueue 線程同步和線程安全

9.1 NSOperation、NSOperationQueue 非線程安全

9.2 NSOperation、NSOperationQueue 線程安全

10. NSOperation、NSOperationQueue 常用屬性和方法歸納

10.1 NSOperation 常用屬性和方法

10.2 NSOperationQueue 常用屬性和方法

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

NSOperation、NSOperationQueue 簡介

1. NSOperation、NSOperationQueue 簡介

3. NSOperation、NSOperationQueue 使用步驟

4.1.1 使用子類 `NSInvocationOperation`

4.1.2 使用子類 `NSBlockOperation`

5. NSOperationQueue 控制串行執(zhí)行、并發(fā)執(zhí)行

9. NSOperation、NSOperationQueue 線程同步和線程安全

9.1 NSOperation、NSOperationQueue 非線程安全

9.2 NSOperation、NSOperationQueue 線程安全

10. NSOperation、NSOperationQueue 常用屬性和方法歸納