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是个抽象类，实际运用时中需要使用它的子类，有三种方式：

  1. 使用子类NSInvocationOperation
  2. 使用子类NSBlockOperation
  3. 定义继承自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];

注意：

  1. 非主队列（其他队列）可以实现串行或并行。
  2. 队列NSOperationQueue有一个参数叫做最大并发数：maxConcurrentOperationCount。
  3. maxConcurrentOperationCount默认为-1，直接并发执行，所以加入到‘非队列’中的任务默认就是并发，开启多线程。
  4. 当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。
  5. 当maxConcurrentOperationCount大于1时，进行并发执行。
  6. 系统对最大并发数有一个限制，所以即使程序员把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

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,383评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,522评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,852评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,621评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,741评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,929评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,076评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,803评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,265评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,582评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,716评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,395评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,039评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,798评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,027评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,488评论 2赞 361
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,612评论 2赞 350

推荐阅读更多精彩内容