2.iOS多線程

多線程的四種解決方案：pthread，NSThread，GCD，NSOperation

image.png

一、多線程的基本概念
進程：可以理解成一個運行中的應用程序，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎，主要管理資源。

線程：是進程的基本執行單元，一個進程對應多個線程。

主線程：處理UI，所有更新UI的操作都必須在主線程上執行。不要把耗時操作放在主線程，會卡界面。

多線程：在同一時刻，一個CPU只能處理1條線程，但CPU可以在多條線程之間快速的切換，只要切換的足夠快，就造成了多線程一同執行的假象。

我們運用多線程的目的是：將耗時的操作放在后臺執行！
//--------------------------- <#我是分割線#> ------------------------------//

進程：一個可執行的程序
任務：一塊可執行的代碼
線程：指的是一個獨立的代碼執行路徑，線程是代碼執行路徑的最小分支
串行和并行：串行是一次只能執行一個任務，并行是一次能執行多個任務
并行是CPU的多核芯同時執行多個任務  并發是單核CPU交替執行兩個任務

//--------------------------- <#我是分割線#> ------------------------------//

一、多線程的基本概念

進程：可以理解成一個運行中的應用程序，是系統進行資源分配和調度的基本單位，是操作系統結構的基礎，主要管理資源。

線程：是進程的基本執行單元，一個進程對應多個線程。

主線程：處理UI，所有更新UI的操作都必須在主線程上執行。不要把耗時操作放在主線程，會卡界面。

多線程：在同一時刻，一個CPU只能處理1條線程，但CPU可以在多條線程之間快速的切換，只要切換的足夠快，就造成了多線程一同執行的假象。

線程就像火車的一節車廂，進程則是火車。車廂（線程）離開火車（進程）是無法跑動的，而火車（進程）至少有一節車廂（主線程）。多線程可以看做多個車廂，它的出現是為了提高效率。
多線程是通過提高資源使用率來提高系統總體的效率。

我們運用多線程的目的是：將耗時的操作放在后臺執行！

二、線程的狀態與生命周期

線程的生命周期是：新建 - 就緒 - 運行 - 阻塞 - 死亡

下面分別闡述線程生命周期中的每一步

新建：實例化線程對象

就緒：向線程對象發送start消息，線程對象被加入可調度線程池等待CPU調度。

運行：CPU 負責調度可調度線程池中線程的執行。線程執行完成之前，狀態可能會在就緒和運行之間來回切換。就緒和運行之間的狀態變化由CPU負責，程序員不能干預。

阻塞：當滿足某個預定條件時，可以使用休眠或鎖，阻塞線程執行。sleepForTimeInterval（休眠指定時長），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥鎖）。

死亡：正常死亡，線程執行完畢。非正常死亡，當滿足某個條件后，在線程內部中止執行/在主線程中止線程對象

還有線程的exit和cancel
[NSThread exit]：一旦強行終止線程，后續的所有代碼都不會被執行。
[thread cancel]取消：并不會直接取消線程，只是給線程對象添加 isCancelled 標記。

三、多線程的四種解決方案

多線程的四種解決方案分別是：pthread，NSThread，GCD， NSOperation。

pthread：運用C語言，是一套通用的API，可跨平臺Unix/Linux/Windows。線程的生命周期由程序員管理。
NSThread：面向對象，可直接操作線程對象。線程的生命周期由程序員管理。
GCD：代替NSThread，可以充分利用設備的多核，自動管理線程生命周期。
NSOperation：底層是GCD，比GCD多了一些方法，更加面向對象，自動管理線程生命周期。

四、線程安全問題

當多個線程訪問同一塊資源時，很容易引發數據錯亂和數據安全問題。就好比幾個人在同一時修改同一個表格，造成數據的錯亂。

解決多線程安全問題的方法

方法一：互斥鎖（同步鎖）

@synchronized(鎖對象) {
    // 需要鎖定的代碼
}

判斷的時候鎖對象要存在，如果代碼中只有一個地方需要加鎖，大多都使用self作為鎖對象，這樣可以避免單獨再創建一個鎖對象。
加了互斥做的代碼，當新線程訪問時，如果發現其他線程正在執行鎖定的代碼，新線程就會進入休眠。

方法二：自旋鎖
加了自旋鎖，當新線程訪問代碼時，如果發現有其他線程正在鎖定代碼，新線程會用死循環的方式，一直等待鎖定的代碼執行完成。相當于不停嘗試執行代碼，比較消耗性能。
屬性修飾atomic本身就有一把自旋鎖。

下面說一下屬性修飾nonatomic 和 atomic

nonatomic 非原子屬性,同一時間可以有很多線程讀和寫
atomic 原子屬性(線程安全)，保證同一時間只有一個線程能夠寫入(但是同一個時間多個線程都可以取值)，atomic 本身就有一把鎖(自旋鎖)

atomic：線程安全，需要消耗大量的資源
nonatomic：非線程安全，不過效率更高，一般使用nonatomic

五、NSThread的使用

No.1：NSThread創建線程

NSThread有三種創建方式：

init方式
detachNewThreadSelector創建好之后自動啟動
performSelectorInBackground創建好之后也是直接啟動

/** 方法一，需要start */
NSThread *thread1 = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething1:) object:@"NSThread1"];
// 線程加入線程池等待CPU調度，時間很快，幾乎是立刻執行
[thread1 start];

/** 方法二，創建好之后自動啟動 */
[NSThread detachNewThreadSelector:@selector(doSomething2:) toTarget:self withObject:@"NSThread2"];

/** 方法三，隱式創建，直接啟動 */
[self performSelectorInBackground:@selector(doSomething3:) withObject:@"NSThread3"];

- (void)doSomething1:(NSObject *)object {
    // 傳遞過來的參數
    NSLog(@"%@",object);
    NSLog(@"doSomething1：%@",[NSThread currentThread]);
}

- (void)doSomething2:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething2：%@",[NSThread currentThread]);
}

- (void)doSomething3:(NSObject *)object {
    NSLog(@"%@",object);
    NSLog(@"doSomething3：%@",[NSThread currentThread]);
}

No.2：NSThread的類方法

返回當前線程

// 當前線程
[NSThread currentThread];
NSLog(@"%@",[NSThread currentThread]);

// 如果number=1，則表示在主線程，否則是子線程
打印結果：<NSThread: 0x608000261380>{number = 1, name = main}

阻塞休眠

//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定時間
[NSThread sleepUntilDate:[NSDate date]];

類方法補充

//退出線程
[NSThread exit];
//判斷當前線程是否為主線程
[NSThread isMainThread];
//判斷當前線程是否是多線程
[NSThread isMultiThreaded];
//主線程的對象
NSThread *mainThread = [NSThread mainThread];

No.3：NSThread的一些屬性

//線程是否在執行
thread.isExecuting;
//線程是否被取消
thread.isCancelled;
//線程是否完成
thread.isFinished;
//是否是主線程
thread.isMainThread;
//線程的優先級，取值范圍0.0到1.0，默認優先級0.5，1.0表示最高優先級，優先級高，CPU調度的頻率高
 thread.threadPriority;

Demo：XM_Thread

六、GCD的理解與使用

No.1：GCD的特點

GCD會自動利用更多的CPU內核

GCD自動管理線程的生命周期（創建線程，調度任務，銷毀線程等）

程序員只需要告訴 GCD 想要如何執行什么任務，不需要編寫任何線程管理代碼

No.2：GCD的基本概念

任務（block）：任務就是將要在線程中執行的代碼，將這段代碼用block封裝好，然后將這個任務添加到指定的執行方式（同步執行和異步執行），等待CPU從隊列中取出任務放到對應的線程中執行。

同步（sync）：一個接著一個，前一個沒有執行完，后面不能執行，不開線程。

異步（async）：開啟多個新線程，任務同一時間可以一起執行。異步是多線程的代名詞

隊列：裝載線程任務的隊形結構。(系統以先進先出的方式調度隊列中的任務執行)。在GCD中有兩種隊列：串行隊列和并發隊列。

并發隊列：線程可以同時一起進行執行。實際上是CPU在多條線程之間快速的切換。（并發功能只有在異步（dispatch_async）函數下才有效）

串行隊列：線程只能依次有序的執行。

GCD總結：將任務(要在線程中執行的操作block)添加到隊列(自己創建或使用全局并發隊列)，并且指定執行任務的方式(異步dispatch_async，同步dispatch_sync)

No.3：隊列的創建方法

使用dispatch_queue_create來創建隊列對象，傳入兩個參數，第一個參數表示隊列的唯一標識符，可為空。第二個參數用來表示串行隊列（DISPATCH_QUEUE_SERIAL）或并發隊列（DISPATCH_QUEUE_CONCURRENT）。

// 串行隊列
dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);
// 并發隊列
dispatch_queue_t queue1 = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

GCD的隊列還有另外兩種：

主隊列：主隊列負責在主線程上調度任務，如果在主線程上已經有任務正在執行，主隊列會等到主線程空閑后再調度任務。通常是返回主線程更新UI的時候使用。dispatch_get_main_queue()

    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗時操作放在這里

        dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主線程進行UI操作

        });
    });

全局并發隊列：全局并發隊列是就是一個并發隊列，是為了讓我們更方便的使用多線程。dispatch_get_global_queue(0, 0)

//全局并發隊列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//全局并發隊列的優先級
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高優先級
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默認（中）優先級
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低優先級
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后臺優先級
//iOS8開始使用服務質量，現在獲取全局并發隊列時，可以直接傳0
dispatch_get_global_queue(0, 0);

No.4：同步/異步/任務、創建方式

同步（sync）使用dispatch_sync來表示。
異步（async）使用dispatch_async。
任務就是將要在線程中執行的代碼，將這段代碼用block封裝好。
代碼如下：

    // 同步執行任務
    dispatch_sync(dispatch_get_global_queue(0, 0), ^{
        // 任務放在這個block里
        NSLog(@"我是同步執行的任務");

    });
    // 異步執行任務
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 任務放在這個block里
        NSLog(@"我是異步執行的任務");

    });

Demo：XM_Thread

No.5：GCD的使用

由于有多種隊列（串行/并發/主隊列）和兩種執行方式（同步/異步），所以他們之間可以有多種組合方式。

串行同步
串行異步
并發同步
并發異步
主隊列同步
主隊列異步

串行同步
執行完一個任務，再執行下一個任務。不開啟新線程。

/** 串行同步 */
- (void)syncSerial {

    NSLog(@"\n\n**************串行同步***************\n\n");

    // 串行隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);

    // 同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行同步3   %@",[NSThread currentThread]);
        }
    });
}
    NSLog(@"\n\n**************end***************\n\n");

輸入結果為順序執行，都在主線程：

**************串行同步***************


2018-05-09 09:19:05.340175+0800 XM_Mediator_Example[52960:4954783] 串行同步1   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.340586+0800 XM_Mediator_Example[52960:4954783] 串行同步1   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341198+0800 XM_Mediator_Example[52960:4954783] 串行同步1   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341395+0800 XM_Mediator_Example[52960:4954783] 串行同步2   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341571+0800 XM_Mediator_Example[52960:4954783] 串行同步2   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341727+0800 XM_Mediator_Example[52960:4954783] 串行同步2   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.341952+0800 XM_Mediator_Example[52960:4954783] 串行同步3   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.342184+0800 XM_Mediator_Example[52960:4954783] 串行同步3   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.342395+0800 XM_Mediator_Example[52960:4954783] 串行同步3   <NSThread: 0x604000078f80>{number = 1, name = main}
2018-05-09 09:19:05.342795+0800 XM_Mediator_Example[52960:4954783] 

**************end***************

串行異步
開啟新線程，但因為任務是串行的，所以還是按順序執行任務。

/** 串行異步 */
- (void)asyncSerial {

    NSLog(@"\n\n**************串行異步***************\n\n");

    // 串行隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_SERIAL);

    // 同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行異步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行異步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"串行異步3   %@",[NSThread currentThread]);
        }
    });
    NSLog(@"\n\n**************end***************\n\n");
}

輸入結果為順序執行，有不同線程：

**************串行異步***************


2018-05-09 09:20:46.996620+0800 XM_Mediator_Example[53058:4965801] 

**************end***************
2018-05-09 09:20:46.996721+0800 XM_Mediator_Example[53058:4966256] 串行異步1   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.996938+0800 XM_Mediator_Example[53058:4966256] 串行異步1   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997423+0800 XM_Mediator_Example[53058:4966256] 串行異步1   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997598+0800 XM_Mediator_Example[53058:4966256] 串行異步2   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997825+0800 XM_Mediator_Example[53058:4966256] 串行異步2   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.997976+0800 XM_Mediator_Example[53058:4966256] 串行異步2   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.998212+0800 XM_Mediator_Example[53058:4966256] 串行異步3   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.998433+0800 XM_Mediator_Example[53058:4966256] 串行異步3   <NSThread: 0x600000678380>{number = 3, name = (null)}
2018-05-09 09:20:46.998721+0800 XM_Mediator_Example[53058:4966256] 串行異步3   <NSThread: 0x600000678380>{number = 3, name = (null)}

并發同步
因為是同步的，所以執行完一個任務，再執行下一個任務。不會開啟新線程。

/** 并發同步 */
- (void)syncConcurrent {
    NSLog(@"\n\n**************并發同步***************\n\n");
    // 并發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 同步執行
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并發同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并發同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并發同步3   %@",[NSThread currentThread]);
        }
    });
NSLog(@"\n\n**************end***************\n\n");
}

輸入結果為順序執行，都在主線程：

**************并發同步***************


2018-05-09 09:22:20.661175+0800 XM_Mediator_Example[53142:4976084] 并發同步1   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661465+0800 XM_Mediator_Example[53142:4976084] 并發同步1   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661625+0800 XM_Mediator_Example[53142:4976084] 并發同步1   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661767+0800 XM_Mediator_Example[53142:4976084] 并發同步2   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.661890+0800 XM_Mediator_Example[53142:4976084] 并發同步2   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.662199+0800 XM_Mediator_Example[53142:4976084] 并發同步2   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.662749+0800 XM_Mediator_Example[53142:4976084] 并發同步3   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.663246+0800 XM_Mediator_Example[53142:4976084] 并發同步3   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.663565+0800 XM_Mediator_Example[53142:4976084] 并發同步3   <NSThread: 0x6040000637c0>{number = 1, name = main}
2018-05-09 09:22:20.663781+0800 XM_Mediator_Example[53142:4976084] 

**************end***************

并發異步
任務交替執行，開啟多線程。

/** 并發異步 */
- (void)asyncConcurrent {
    NSLog(@"\n\n**************并發異步***************\n\n");
    // 并發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 同步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并發異步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并發異步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"并發異步3   %@",[NSThread currentThread]);
        }
    });
    NSLog(@"\n\n**************end***************\n\n");
}

輸入結果為無序執行，有多條線程：

**************并發異步***************


2018-05-09 09:23:48.985161+0800 XM_Mediator_Example[53236:4985467] 

**************end***************
2018-05-09 09:23:48.985313+0800 XM_Mediator_Example[53236:4985948] 并發異步3   <NSThread: 0x60000066b140>{number = 4, name = (null)}
2018-05-09 09:23:48.985324+0800 XM_Mediator_Example[53236:4985949] 并發異步2   <NSThread: 0x60000066bac0>{number = 5, name = (null)}
2018-05-09 09:23:48.985346+0800 XM_Mediator_Example[53236:4985950] 并發異步1   <NSThread: 0x604000665b80>{number = 3, name = (null)}
2018-05-09 09:23:48.986612+0800 XM_Mediator_Example[53236:4985948] 并發異步3   <NSThread: 0x60000066b140>{number = 4, name = (null)}
2018-05-09 09:23:48.986821+0800 XM_Mediator_Example[53236:4985950] 并發異步1   <NSThread: 0x604000665b80>{number = 3, name = (null)}
2018-05-09 09:23:48.986822+0800 XM_Mediator_Example[53236:4985949] 并發異步2   <NSThread: 0x60000066bac0>{number = 5, name = (null)}
2018-05-09 09:23:48.986972+0800 XM_Mediator_Example[53236:4985950] 并發異步1   <NSThread: 0x604000665b80>{number = 3, name = (null)}
2018-05-09 09:23:48.987191+0800 XM_Mediator_Example[53236:4985948] 并發異步3   <NSThread: 0x60000066b140>{number = 4, name = (null)}
2018-05-09 09:23:48.988051+0800 XM_Mediator_Example[53236:4985949] 并發異步2   <NSThread: 0x60000066bac0>{number = 5, name = (null)}

主隊列同步
如果在主線程中運用這種方式，則會發生死鎖，程序崩潰。

/** 主隊列同步 */
- (void)syncMain {

    NSLog(@"\n\n**************主隊列同步，放到主線程會死鎖***************\n\n");

    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_sync(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列同步3   %@",[NSThread currentThread]);
        }
    });
}

主隊列同步造成死鎖的原因：
如果在主線程中運用主隊列同步，也就是把任務放到了主線程的隊列中。
而同步對于任務是立刻執行的，那么當把第一個任務放進主隊列時，它就會立馬執行。
可是主線程現在正在處理syncMain方法，任務需要等syncMain執行完才能執行。
syncMain執行到第一個任務的時候，又要等第一個任務執行完才能往下執行第二個和第三個任務。
這樣syncMain方法和第一個任務就開始了互相等待，形成了死鎖。

主隊列異步
在主線程中任務按順序執行。

/** 主隊列異步 */
- (void)asyncMain {

    NSLog(@"\n\n**************主隊列異步***************\n\n");

    // 主隊列
    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列異步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列異步2   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"主隊列異步3   %@",[NSThread currentThread]);
        }
    });
}

輸入結果為在主線程中按順序執行：

主隊列異步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步1   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步2   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3   <NSThread: 0x60000007c500>{number = 1, name = main}
主隊列異步3   <NSThread: 0x60000007c500>{number = 1, name = main}

GCD線程之間的通訊
開發中需要在主線程上進行UI的相關操作，通常會把一些耗時的操作放在其他線程，比如說圖片文件下載等耗時操作。
當完成了耗時操作之后，需要回到主線程進行UI的處理，這里就用到了線程之間的通訊。

- (IBAction)communicationBetweenThread:(id)sender {

    // 異步
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 耗時操作放在這里，例如下載圖片。（運用線程休眠兩秒來模擬耗時操作）
        [NSThread sleepForTimeInterval:2];
        NSString *picURLStr = @"http://www.bangmangxuan.net/uploads/allimg/160320/74-160320130500.jpg";
        NSURL *picURL = [NSURL URLWithString:picURLStr];
        NSData *picData = [NSData dataWithContentsOfURL:picURL];
        UIImage *image = [UIImage imageWithData:picData];

        // 回到主線程處理UI
        dispatch_async(dispatch_get_main_queue(), ^{
            // 在主線程上添加圖片
            self.imageView.image = image;
        });
    });
}

上面的代碼是在新開的線程中進行圖片的下載，下載完成之后回到主線程顯示圖片。

GCD柵欄
當任務需要異步進行，但是這些任務需要分成兩組來執行，第一組完成之后才能進行第二組的操作。這時候就用了到GCD的柵欄方法dispatch_barrier_async。

- (IBAction)barrierGCD:(id)sender {

    // 并發隊列
    dispatch_queue_t queue = dispatch_queue_create("test", DISPATCH_QUEUE_CONCURRENT);

    // 異步執行
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：并發異步1   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：并發異步2   %@",[NSThread currentThread]);
        }
    });

    dispatch_barrier_async(queue, ^{
        NSLog(@"------------barrier------------%@", [NSThread currentThread]);
        NSLog(@"******* 并發異步執行，但是34一定在12后面 *********");
    });

    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：并發異步3   %@",[NSThread currentThread]);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"柵欄：并發異步4   %@",[NSThread currentThread]);
        }
    });
}

上面代碼的打印結果如下，開啟了多條線程，所有任務都是并發異步進行。但是第一組完成之后，才會進行第二組的操作。

柵欄：并發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發異步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發異步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發異步1   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發異步2   <NSThread: 0x60000026e480>{number = 6, name = (null)}
 ------------barrier------------<NSThread: 0x60000026e480>{number = 6, name = (null)}
******* 并發異步執行，但是34一定在12后面 *********
柵欄：并發異步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發異步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發異步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發異步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}
柵欄：并發異步4   <NSThread: 0x60000026d740>{number = 3, name = (null)}
柵欄：并發異步3   <NSThread: 0x60000026e480>{number = 6, name = (null)}

GCD延時執行
當需要等待一會再執行一段代碼時，就可以用到這個方法了：dispatch_after。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 5秒后異步執行
    NSLog(@"我已經等待了5秒！");
});

GCD實現代碼只執行一次
使用dispatch_once能保證某段代碼在程序運行過程中只被執行1次。可以用來設計單例。

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    NSLog(@"程序運行過程中我只執行了一次！");
});

GCD快速迭代
GCD有一個快速迭代的方法dispatch_apply，dispatch_apply可以同時遍歷多個數字。

- (IBAction)applyGCD:(id)sender {

    NSLog(@"\n\n************** GCD快速迭代 ***************\n\n");

    // 并發隊列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);

    // dispatch_apply幾乎同時遍歷多個數字
    dispatch_apply(7, queue, ^(size_t index) {
        NSLog(@"dispatch_apply：%zd======%@",index, [NSThread currentThread]);
    });
}

打印結果如下：

dispatch_apply：0======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：1======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：2======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：3======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：4======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：5======<NSThread: 0x60000007c500>{number = 1, name = main}
dispatch_apply：6======<NSThread: 0x60000007c500>{number = 1, name = main}

GCD隊列組
異步執行幾個耗時操作，當這幾個操作都完成之后再回到主線程進行操作，就可以用到隊列組了。
隊列組有下面幾個特點：

所有的任務會并發的執行(不按序)。
所有的異步函數都添加到隊列中，然后再納入隊列組的監聽范圍。
使用dispatch_group_notify函數，來監聽上面的任務是否完成，如果完成, 就會調用這個方法。

隊列組示例代碼：

- (void)testGroup {
    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"隊列組：有一個耗時操作完成！");
    });

    dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"隊列組：有一個耗時操作完成！");
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"隊列組：前面的耗時操作都完成了，回到主線程進行相關操作");
    });
}

打印結果如下：

隊列組：有一個耗時操作完成！
隊列組：有一個耗時操作完成！
隊列組：前面的耗時操作都完成了，回到主線程進行相關操作

6.6 GCD 信號量：dispatch_semaphore

GCD 中的信號量是指Dispatch Semaphore，是持有計數的信號。類似于過高速路收費站的欄桿。可以通過時，打開欄桿，不可以通過時，關閉欄桿。在Dispatch Semaphore中，使用計數來完成這個功能，計數為0時等待，不可通過。計數為1或大于1時，計數減1且不等待，可通過。
Dispatch Semaphore提供了三個函數。

dispatch_semaphore_create：創建一個Semaphore并初始化信號的總量

dispatch_semaphore_signal：發送一個信號，讓信號總量加1

dispatch_semaphore_wait：可以使總信號量減1，當信號總量為0時就會一直等待（阻塞所在線程），否則就可以正常執行。
注意：信號量的使用前提是：想清楚你需要處理哪個線程等待（阻塞），又要哪個線程繼續執行，然后使用信號量。

Dispatch Semaphore 在實際開發中主要用于：
保持線程同步，將異步執行任務轉換為同步執行任務
保證線程安全，為線程加鎖
6.6.1 Dispatch Semaphore 線程同步

我們在開發中，會遇到這樣的需求：異步執行耗時任務，并使用異步執行的結果進行一些額外的操作。換句話說，相當于，將將異步執行任務轉換為同步執行任務。比如說：AFNetworking 中 AFURLSessionManager.m 里面的tasksForKeyPath:方法。通過引入信號量的方式，等待異步執行任務結果，獲取到 tasks，然后再返回該 tasks。

- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
    __block NSArray *tasks = nil;
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
        if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
            tasks = dataTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
            tasks = uploadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
            tasks = downloadTasks;
        } else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
            tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
        }

        dispatch_semaphore_signal(semaphore);
    }];

    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

    return tasks;
}

下面，我們來利用 Dispatch Semaphore 實現線程同步，將異步執行任務轉換為同步執行任務。

+ (void)semaphoreSync
{
    NSLog(@"currentThread---%@",[NSThread currentThread]);// 打印當前線程NSLog(@"semaphore---begin");
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    __block int number =0;
    dispatch_async(queue, ^{// 追加任務1
        [NSThread sleepForTimeInterval:2];
        // 模擬耗時操作
        NSLog(@"1---%@",[NSThread currentThread]);
        // 打印當前線程number =100;
          dispatch_semaphore_signal(semaphore);
        
          });
    
      dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"semaphore---end,number = %zd",number);
    
}

image.png

6.6.2 Dispatch Semaphore 線程安全和線程同步（為線程加鎖）

線程安全：如果你的代碼所在的進程中有多個線程在同時運行，而這些線程可能會同時運行這段代碼。如果每次運行結果和單線程運行的結果是一樣的，而且其他的變量的值也和預期的是一樣的，就是線程安全的。

若每個線程中對全局變量、靜態變量只有讀操作，而無寫操作，一般來說，這個全局變量是線程安全的；若有多個線程同時執行寫操作（更改變量），一般都需要考慮線程同步，否則的話就可能影響線程安全。

線程同步：可理解為線程 A 和線程 B 一塊配合，A 執行到一定程度時要依靠線程 B 的某個結果，于是停下來，示意 B 運行；B 依言執行，再將結果給 A；A 再繼續操作。

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

6.6.2.2 線程安全（使用 semaphore 加鎖）買票

+ (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);// 打印當前線程
    NSLog(@"semaphore---begin");
    semaphoreLock = dispatch_semaphore_create(1);
    ticketSurplusCount =50;// queue1 代表北京火車票售賣窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_CONCURRENT);// queue2 代表上海火車票售賣窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_CONCURRENT);
    __weak typeof(self) weakSelf =self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });
    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
    NSLog(@"initTicketStatusSave---end");
}

+ (void)saleTicketSafe {
    while(1) {// 相當于加鎖
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
        if(ticketSurplusCount >0) {//如果還有票，繼續售賣
            ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票數：%d 窗口：%@",ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }else{//如果已賣完，關閉售票窗口
            NSLog(@"所有火車票均已售完");
            // 相當于解鎖
            dispatch_semaphore_signal(semaphoreLock);
            break;
            }
        // 相當于解鎖
        dispatch_semaphore_signal(semaphoreLock);
    }
}

至此，GCD的相關內容敘述完畢。下面讓我們繼續學習NSOperation。

Demo：XM_Thread

七、NSOperation的理解與使用

No.1：NSOperation簡介

NSOperation是基于GCD之上的更高一層封裝，NSOperation需要配合NSOperationQueue來實現多線程。

NSOperation實現多線程的步驟如下：

1. 創建任務：先將需要執行的操作封裝到NSOperation對象中。
2. 創建隊列：創建NSOperationQueue。
3. 將任務加入到隊列中：將NSOperation對象添加到NSOperationQueue中。

需要注意的是，NSOperation是個抽象類，實際運用時中需要使用它的子類，有三種方式：

使用子類NSInvocationOperation

使用子類NSBlockOperation

定義繼承自NSOperation的子類，通過實現內部相應的方法來封裝任務。

No.2：NSOperation的三種創建方式

NSInvocationOperation的使用
創建NSInvocationOperation對象并關聯方法，之后start。

- (void)testNSInvocationOperation {
    // 創建NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperation) object:nil];
    // 開始執行操作
    [invocationOperation start];
}

- (void)invocationOperation {
    NSLog(@"NSInvocationOperation包含的任務，沒有加入隊列========%@", [NSThread currentThread]);
}

打印結果如下，得到結論：程序在主線程執行，沒有開啟新線程。
這是因為NSOperation多線程的使用需要配合隊列NSOperationQueue，后面會講到NSOperationQueue的使用。

NSInvocationOperation包含的任務，沒有加入隊列========<NSThread: 0x6000000783c0>{number = 1, name = main}

NSBlockOperation的使用
把任務放到NSBlockOperation的block中，然后start。

- (void)testNSBlockOperation {
    // 把任務放到block中
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation包含的任務，沒有加入隊列========%@", [NSThread currentThread]);
    }];

    [blockOperation start];
}

執行結果如下，可以看出：主線程執行，沒有開啟新線程。
同樣的，NSBlockOperation可以配合隊列NSOperationQueue來實現多線程。

NSBlockOperation包含的任務，沒有加入隊列========<NSThread: 0x6000000783c0>{number = 1, name = main}

但是NSBlockOperation有一個方法addExecutionBlock:，通過這個方法可以讓NSBlockOperation實現多線程。

- (void)testNSBlockOperationExecution {
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock主任務========%@", [NSThread currentThread]);
    }];

    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務1========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務2========%@", [NSThread currentThread]);
    }];
    [blockOperation addExecutionBlock:^{
        NSLog(@"NSBlockOperation運用addExecutionBlock方法添加任務3========%@", [NSThread currentThread]);
    }];

    [blockOperation start];
}

執行結果如下，可以看出，NSBlockOperation創建時block中的任務是在主線程執行，而運用addExecutionBlock加入的任務是在子線程執行的。

NSBlockOperation運用addExecutionBlock========<NSThread: 0x60800006ccc0>{number = 1, name = main}
addExecutionBlock方法添加任務1========<NSThread: 0x60800007ec00>{number = 3, name = (null)}
addExecutionBlock方法添加任務3========<NSThread: 0x6000002636c0>{number = 5, name = (null)}
addExecutionBlock方法添加任務2========<NSThread: 0x60800007e800>{number = 4, name = (null)}

運用繼承自NSOperation的子類
首先我們定義一個繼承自NSOperation的類，然后重寫它的main方法，之后就可以使用這個子類來進行相關的操作了。

/*******************"WHOperation.h"*************************/

#import <Foundation/Foundation.h>

@interface WHOperation : NSOperation

@end

/*******************"WHOperation.m"*************************/

#import "WHOperation.h"

@implementation WHOperation

- (void)main {
    for (int i = 0; i < 3; i++) {
        NSLog(@"NSOperation的子類WHOperation======%@",[NSThread currentThread]);
    }
}

@end

/*****************回到主控制器使用WHOperation**********************/

- (void)testWHOperation {
    WHOperation *operation = [[WHOperation alloc] init];
    [operation start];
}

運行結果如下，依然是在主線程執行。

SOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}
NSOperation的子類WHOperation======<NSThread: 0x608000066780>{number = 1, name = main}

所以，NSOperation是需要配合隊列NSOperationQueue來實現多線程的。下面就來說一下隊列NSOperationQueue。

No.3：隊列NSOperationQueue

NSOperationQueue只有兩種隊列：主隊列、其他隊列。其他隊列包含了串行和并發。

主隊列的創建如下，主隊列上的任務是在主線程執行的。

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

其他隊列（非主隊列）的創建如下，加入到‘非隊列’中的任務默認就是并發，開啟多線程。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

注意：

非主隊列（其他隊列）可以實現串行或并行。
隊列NSOperationQueue有一個參數叫做最大并發數：maxConcurrentOperationCount。
maxConcurrentOperationCount默認為-1，直接并發執行，所以加入到‘非隊列’中的任務默認就是并發，開啟多線程。
當maxConcurrentOperationCount為1時，則表示不開線程，也就是串行。
當maxConcurrentOperationCount大于1時，進行并發執行。
系統對最大并發數有一個限制，所以即使程序員把maxConcurrentOperationCount設置的很大，系統也會自動調整。所以把最大并發數設置的很大是沒有意義的。

No.4：NSOperation + NSOperationQueue

把任務加入隊列，這才是NSOperation的常規使用方式。

addOperation添加任務到隊列

先創建好任務，然后運用- (void)addOperation:(NSOperation *)op 方法來吧任務添加到隊列中，示例代碼如下：

- (void)testOperationQueue {
    // 創建隊列，默認并發
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 創建操作，NSInvocationOperation
    NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationAddOperation) object:nil];
    // 創建操作，NSBlockOperation
    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperation把任務添加到隊列======%@", [NSThread currentThread]);
        }
    }];

    [queue addOperation:invocationOperation];
    [queue addOperation:blockOperation];
}

- (void)invocationOperationAddOperation {
    NSLog(@"invocationOperation===aaddOperation把任務添加到隊列====%@", [NSThread currentThread]);
}

運行結果如下，可以看出，任務都是在子線程執行的，開啟了新線程！

invocationOperation===addOperation把任務添加到隊列====<NSThread: 0x60800026ed00>{number = 4, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}
addOperation把任務添加到隊列======<NSThread: 0x60800026e640>{number = 3, name = (null)}

addOperationWithBlock添加任務到隊列

這是一個更方便的把任務添加到隊列的方法，直接把任務寫在block中，添加到任務中。

- (void)testAddOperationWithBlock {
    // 創建隊列，默認并發
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 添加操作到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列======%@", [NSThread currentThread]);
        }
    }];
}

運行結果如下，任務確實是在子線程中執行。

addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列======<NSThread: 0x6000000752c0>{number = 3, name = (null)}

運用最大并發數實現串行
上面已經說過，可以運用隊列的屬性maxConcurrentOperationCount（最大并發數）來實現串行，值需要把它設置為1就可以了，下面我們通過代碼驗證一下。

- (void)testMaxConcurrentOperationCount {
    // 創建隊列，默認并發
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 最大并發數為1，串行
    queue.maxConcurrentOperationCount = 1;

    // 最大并發數為2，并發
//    queue.maxConcurrentOperationCount = 2;

    // 添加操作到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列1======%@", [NSThread currentThread]);
        }
    }];

    // 添加操作到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列2======%@", [NSThread currentThread]);
        }
    }];

    // 添加操作到隊列
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"addOperationWithBlock把任務添加到隊列3======%@", [NSThread currentThread]);
        }
    }];
}

運行結果如下，當最大并發數為1的時候，雖然開啟了線程，但是任務是順序執行的，所以實現了串行。
你可以嘗試把上面的最大并發數變為2，會發現任務就變成了并發執行。

addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列1======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列2======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}
addOperationWithBlock把任務添加到隊列3======<NSThread: 0x608000068980>{number = 3, name = (null)}

No.5：NSOperation的其他操作

取消隊列NSOperationQueue的所有操作，NSOperationQueue對象方法

- (void)cancelAllOperations

取消NSOperation的某個操作，NSOperation對象方法

- (void)cancel

使隊列暫停或繼續

// 暫停隊列
[queue setSuspended:YES];

判斷隊列是否暫停

- (BOOL)isSuspended

暫停和取消不是立刻取消當前操作，而是等當前的操作執行完之后不再進行新的操作。

No.6：NSOperation的操作依賴

NSOperation有一個非常好用的方法，就是操作依賴。可以從字面意思理解：某一個操作（operation2）依賴于另一個操作（operation1），只有當operation1執行完畢，才能執行operation2，這時，就是操作依賴大顯身手的時候了。

- (void)testAddDependency {

    // 并發隊列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 操作1
    NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 3; i++) {
            NSLog(@"operation1======%@", [NSThread  currentThread]);
        }
    }];

    // 操作2
    NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"****operation2依賴于operation1，只有當operation1執行完畢，operation2才會執行****");
        for (int i = 0; i < 3; i++) {
            NSLog(@"operation2======%@", [NSThread  currentThread]);
        }
    }];

    // 使操作2依賴于操作1
    [operation2 addDependency:operation1];

    // 把操作加入隊列
    [queue addOperation:operation1];
    [queue addOperation:operation2];
}

運行結果如下，操作2總是在操作1之后執行，成功驗證了上面的說法。

operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
operation1======<NSThread: 0x60800026dec0>{number = 3, name = (null)}
****operation2依賴于operation1，只有當operation1執行完畢，operation2才會執行****
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}
operation2======<NSThread: 0x60800026dc80>{number = 4, name = (null)}

其他http://www.cocoachina.com/ios/20170829/20404.html

最后編輯于：2018.05.18 09:35:05

?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 229,327評論 6贊 537
死咒
序言：濱河連續發生了三起死亡事件，死亡現場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發現死者居然都...
沈念sama閱讀 98,996評論 3贊 423
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 177,316評論 0贊 382
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 63,406評論 1贊 316
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 72,128評論 6贊 410
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發上，一...
開封第一講書人閱讀 55,524評論 1贊 324
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 43,576評論 3贊 444
雙鴛鴦連環套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側響起，我...
開封第一講書人閱讀 42,759評論 0贊 289
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當地人在樹林里發現了一具尸體，經...
沈念sama閱讀 49,310評論 1贊 335
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內容為張勛視角年9月15日...
茶點故事閱讀 41,065評論 3贊 356
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發現自己被綠了。大學時的朋友給我發了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 43,249評論 1贊 371
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,821評論 5贊 362
?日本核電站爆炸內幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質發生泄漏。R本人自食惡果不足惜，卻給世界環境...
茶點故事閱讀 44,479評論 3贊 347
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,909評論 0贊 28
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 36,140評論 1贊 290
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,984評論 3贊 395
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 48,228評論 2贊 375

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

2.iOS多線程

2.iOS多線程

一、多線程的基本概念

二、線程的狀態與生命周期

三、多線程的四種解決方案

四、線程安全問題

五、NSThread的使用

六、GCD的理解與使用

No.1：GCD的特點

No.2：GCD的基本概念

No.3：隊列的創建方法

No.4：同步/異步/任務、創建方式

No.5：GCD的使用

6.6 GCD 信號量：dispatch_semaphore

七、NSOperation的理解與使用

No.1：NSOperation簡介

No.2：NSOperation的三種創建方式

No.3：隊列NSOperationQueue

No.4：NSOperation + NSOperationQueue

No.5：NSOperation的其他操作

No.6：NSOperation的操作依賴

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

2.iOS多線程

一、多線程的基本概念

二、線程的狀態與生命周期

三、多線程的四種解決方案

四、線程安全問題

五、NSThread的使用

六、GCD的理解與使用

No.1：GCD的特點

No.2：GCD的基本概念

No.3：隊列的創建方法

No.4：同步/異步/任務、創建方式

No.5：GCD的使用

6.6 GCD 信號量：dispatch_semaphore

七、NSOperation的理解與使用

No.1：NSOperation簡介

No.2：NSOperation的三種創建方式

No.3：隊列NSOperationQueue

No.4：NSOperation + NSOperationQueue

No.5：NSOperation的其他操作

No.6：NSOperation的操作依賴

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频