OC中的多线程

线程与进程

聊到多线程，最先要弄清楚两个概念进程与线程。

这些是计算机的基础知识，推荐一篇文章,讲的挺详细。

进程

进程（Process）是计算机中具有一定独立功能的程序关于某个数据集合的一次运行活动。它可以申请和拥有系统资源，是系统进行资源分配和调度的基本单位。

从狭义上，可以将进程理解为正在运行的程序的实例，当一个程序进入内存运行时，系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。

每一个进程都有它自己的地址空间，一般情况下，进程由 3 个部分组成，分别是程序代码、数据集、栈和进程控制块（Process Control Block）。

程序并不能单独运行，只有将程序装载到内存中，系统为它分配资源才能运行，而这种执行的程序就称之为进程。

程序和进程的区别就在于：程序是指令的集合，它是进程运行的静态描述文本；进程是程序的一次执行活动，属于动态概念。

我们允许多个程序同时加载到内存中，在操作系统的调度下，可以实现并发地执行。这是这样的设计，大大提高了CPU的利用率。进程的出现让每个用户感觉到自己独享CPU。

进程是一个程序执行的实例，是资源分配的最小单位。

进程具有的特征：

并发性：任何进程都可以同其他进行一起并发执行；
动态性：进程是程序的一次执行过程，是临时的，有生命期的，是动态产生，动态消亡的；
独立性：进程是系统进行资源分配和调度的一个独立单位；
结构性：进程由程序，数据和进程控制块三部分组成

线程

线程是进程的一个实体, 是CPU调度和分派的基本单位。

在早期的操作系统中并没有线程的概念，进程是拥有资源和独立运行的最小单位。任务调度采用的是时间片轮转的抢占式调度方式，而进程作为任务调度的最小单位，每个进程有各自独立的一块内存，使得各个进程之间内存地址相互隔离。

后来，随着计算机技术的发展，可运行的进程越来越多。进程出现了很多弊端:

一是由于进程是资源拥有者，创建、撤消与切换存在较大的时空开销，因此需要引入轻型进程；

二是由于对称多处理机（SMP）的出现，可以满足多个运行单位，而多个进程并行开销过大。因此出现了能独立运行的基本单位——线程（Threads）。

线程是程序执行中一个单一的顺序控制流程，是程序执行流的最小单元，是处理器调度和分派的基本单位。

在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位。

由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统内多个程序间并发执行的程度，从而显著提高系统资源的利用率和吞吐量。

进程与线程的关系

一个正在运行的软件(如迅雷)就是一个进程，一个进程可以同时运行多个任务( 迅雷软件可以同时下载多个文件，每个下载任务就是一个线程)。他们的关系如下：

线程是依附于进程的，不能独立存在，它包含在进程之中，是进程中的实际运作单位。进程一旦结束，所有线程都结束。

一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一个线程。

线程是进程中的一个执行单元，由CPU独立调度执行，负责当前进程中任务的执行。一个进程可以有一个或多个线程，线程会拥有自己的堆栈和局部变量（不共享），但是它与同一进程中的多个线程将共享程序的内存空间，也就是该进程中的代码段(代码和常量)，数据段(全局变量和静态变量)，扩展段(堆存储)等系统资源。

进程与线程的区别？

根本区别：进程是操作系统分配资源的最小单位，线程是程序执行的最小单位。
地址空间和其它资源：进程之间相互独立，但同一进程下的各线程共享程序的内存空间及一些进程级的资源。某进程内的线程在其他进程不可见。
调度和切换：线程上下文切换比进程上下文切换要快得多。
通信机制：进程间通信，由于它们具有独立的数据空间，需要进程同步和互斥手段的辅助，以保证数据的一致性，方式不仅耗时，而且不方便；但同一进程下的线程之间数据共享，可以直接读写进程数据段（如全局变量）来进行通信；
内存分配：系统在运行的时候会为每个进程分配不同的内存空间，而线程除了CPU外，不会再分配空间，而是使用进程的资源空间。

拿图来举例：

多线程的优势在于：

线程的调度与切换比进程快很多，同时创建一个线程的开销也比进程要小很多；
线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，线程间通信就是读写同一个变量，速度很快。而进程之间的通信需要以通信的方式（Inter Process Communication，IPC)进行。

多进程的优点在于：

多进程程序更健壮，在多进程的情况下，一个进程崩溃不会影响其他进程，而在多线程的情况下，任何一个线程崩溃会直接导致整个进程崩溃。

线程的状态

新建（new)

创建一个Thread对象就生成一个新线程。创建完成后就需要为线程分配内存。当线程处于"新线程"状态时，仅仅是一个空线程对象，它还没有分配到系统资源。因此只能启动或终止它。任何其他操作都会引发异常。

就绪（Runnable)

一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，创建线程运行所必须的系统资源，并调度线程执行run（）方法，当start()方法返回后，线程就处于就绪状态。

处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此，此时可能有多个线程处于就绪状态。

运行（Running）

当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法。

阻塞（Blocked)

所谓阻塞状态是正在运行的线程没有运行结束，暂时让出CPU，这时其他处于就绪状态的线程就可以获得CPU时间，进入运行状态。

死亡（Dead)

有两个原因会导致线程死亡：

① run()方法正常退出而自然死亡；

② 发生异常或者被打断interrupt()导致线程终止。

关系如图：

多线程的意义

多线程最大的意义，就是最大限度地利用CPU资源。

某个操作可能会陷入长时间等待，等待的线程会进入睡眠状态，无法继续执行。多线程执行可以有效利用等待时间进行线程切换。如等待网络响应。
某个操作可能会消耗大量的时间，如果只有一个线程，程序和用户之间的交互会被中断。多线程可以让一个线程负责交互，另一个线程负责计算。
程序本身要求并发操作，如一个多端下载软件（如Bittorrent）。
多CPU或多核处理器，本身具备同时执行多个线程的能力，因此单线程程序无法全面发挥计算机的全部计算能力。
多线程可以提高程序的效率。多线程同步完成多项任务，不是为了提高运行效率，而是为了提高资源使用效率来提高系统的效率。

当然，多线程也并不是百利而无害的。

开启线程需要占用一定的内存空间（默认情况下，每条线程占512kb）；如果开启大量的线程，会占用大量的内存空间，降低程序的性能。
线程越多，CPU在调用线程上的开销就越大（因为要在线程之间切换）；
多线程编程的程序设计会更加复杂（如线程间的通信、多线程的数据共享等）。使用不当，可能会带来更多的bug

同步、异步

同步和异步主要影响：能不能开启新的线程

同步：在当前线程中执行任务，不具备开启新线程的能力

异步：在新的线程中执行任务，具备开启新线程的能力

串行、并行

并发和串行主要影响：任务的执行方式

并发：多个任务并发（同时）执行

串行：一个任务执行完毕后，再执行下一个任务

总的来说，如图所示：

注意：使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列（产生死锁）

多线程的多种实现

由于开发中使用最多的就是GCD与NSOperatioin，就主要看看这两个。参考文章

GCD

Grand Central Dispatch（GCD） 是 Apple 开发的一个多核编程的较新的解决方法。

它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并发任务。在 Mac OS X 10.6 雪豹中首次推出，也可在 iOS 4 及以上版本使用。

使用GCD好处，具体如下：

GCD 可用于多核的并行运算；
GCD 会自动利用更多的 CPU 内核（比如双核、四核）；
GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）；
程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码。

学习 GCD 之前，先来了解 GCD 中两个核心概念：任务 和 队列。

任务与队列

任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行 和 异步执行。

两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。

同步执行（sync）：
- 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
- 只能在当前线程中执行任务，不具备开启新线程的能力。
异步执行（async）：
- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。

注意：异步执行（async）虽然具有开启新线程的能力，但是并不一定开启新线程。这跟任务所指定的队列类型有关。

队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。

队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。队列的结构可参考下图：

在 GCD 中有两种队列：串行队列 和 并发队列。

两者都符合 FIFO（先进先出）的原则。

两者的主要区别是：执行顺序不同，以及开启线程数不同。

串行队列（Serial Dispatch Queue）：每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

注意：并发队列的并发功能只有在异步（dispatch_async）方法下才有效。

主队列

主队列是一种特殊的串行队列，在libdispatch_init 初始化时就创建了主队列，并且完成了与主线程的绑定。这些都是在程序main()函数之前就已完成的。

也就是说程序完成启动之时就已经有了主队列，并且所有放在主队列中的任务都是在主线程中执行的。不管是同步还是异步都不会开辟新线程，任务只会在主线程执行。这也是通常在主线程刷新UI时会将任务放到主队列的原因。

可通过dispatch_get_main_queue()获取主队列。

全局并发队列

全局并发队列本质上是一个并发队列，由系统提供，方便编程，不用创建就可使用。

可通过dispatch_get_global_queue(long indentifier.unsigned long flags)获取全局并发队列。

该函数提供了两个参数，第一个参数表示队列优先级，通常写0，也就是默认优先级。可以通过服务质量类值来获取不同优先级的全局并发队列。

基础用法

GCD 的使用步骤其实很简单，只有两步：

1、创建一个队列（串行队列或并发队列）；

2、将任务追加到任务的等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）。

创建队列

可以使用dispatch_queue_create方法来创建队列。该方法需要传入两个参数：

第一个参数表示队列的唯一标识符，用于 DEBUG，可为空。队列的名称推荐使用应用程序 ID 这种逆序全程域名。
第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_CONCURRENT 表示并发队列。

// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

主队列: dispatch_queue_t queue = dispatch_get_main_queue();

全局并发队列: dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

创建任务

GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async

// 同步执行任务创建方法
dispatch_sync(queue, ^{
    // 这里放同步执行任务代码
});

// 异步执行任务创建方法
dispatch_async(queue, ^{
    // 这里放异步执行任务代码
});

虽然使用 GCD 只需两步，但是既然我们有两种队列（串行队列 / 并发队列），两种任务执行方式（同步执行 / 异步执行），加上主队列，就有六种组合方式：

同步执行 + 并发队列

异步执行 + 并发队列

同步执行 + 串行队列

异步执行 + 串行队列

同步执行+ 主队列

异步执行+ 主队列

同步执行 + 并发队列

/**
 * 同步执行 + 并发队列
 * 特点：在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"syncConcurrent---begin");

    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_sync(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_sync(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_sync(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程
    });

    NSLog(@"syncConcurrent---end");
}

打印：
[16332:4171500] currentThread—-{number = 1, name = main}
[16332:4171500] syncConcurrent—-begin
[16332:4171500] 1—-{number = 1, name = main}
[16332:4171500] 2—-{number = 1, name = main}
[16332:4171500] 3—-{number = 1, name = main}
[16332:4171500] syncConcurrent—-end

可以看出：所有任务都是在当前线程（主线程）中执行的，没有开启新的线程（同步执行不具备开启新线程的能力）。

按顺序执行的原因：虽然 并发队列 可以开启多个线程，并且同时执行多个任务。但是因为本身不能创建新线程，只有当前线程这一个线程（同步任务不具备开启新线程的能力），所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后，才能继续接着执行下面的操作（同步任务需要等待队列的任务执行结束）。

所以任务只能一个接一个按顺序执行，不能同时被执行。

异步执行 + 并发队列

/**
 * 异步执行 + 并发队列
 * 特点：可以开启多个线程，任务交替（同时）执行。
 */
- (void)asyncConcurrent {
    NSLog(@"currentThread---%@",[NSThread currentThread]); 
    NSLog(@"asyncConcurrent---begin");

    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);// 打印当前线程
    });

    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_async(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
    });

    NSLog(@"asyncConcurrent---end");
}

打印：
[17232:4187114] currentThread—-{number = 1, name = main}
[17232:4187114] asyncConcurrent—-begin
[17232:4187114] asyncConcurrent—-end[17232:4187204] 2—-{number = 3, name = (null)}
[17232:4187202] 3—-{number = 5, name = (null)}
[17232:4187203] 1—-{number = 4, name = (null)}

可以看出：除了当前线程（主线程），系统又开启了 3 个线程，并且任务是交替/同时执行的。（异步执行具备开启新线程的能力。且并发队列可开启多个线程，同时执行多个任务）。

说明当前线程没有等待，而是直接开启了新线程，在新线程中执行任务（异步执行不做等待，可以继续执行任务）。

同步执行 + 串行队列

/**
 * 同步执行 + 串行队列
 * 特点：不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)syncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"syncSerial---begin");

    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

    dispatch_sync(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);// 打印当前线程
    });
    dispatch_sync(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);// 打印当前线程
    });
    dispatch_sync(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程
    });

    NSLog(@"syncSerial---end");
}

打印：
[17285:4197645] currentThread—-{number = 1, name = main}
[17285:4197645] syncSerial—-begin
[17285:4197645] 1—-{number = 1, name = main}
[17285:4197645] 2—-{number = 1, name = main}
[17285:4197645] 3—-{number = 1, name = main}
[17285:4197645] syncSerial—-end

可以看到：所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（同步执行不具备开启新线程的能力）。

任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

异步执行 + 串行队列

/**
 * 异步执行 + 串行队列
 * 特点：会开启新线程，但是因为任务是串行的，执行完一个任务，再执行下一个任务。
 */
- (void)asyncSerial {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"asyncSerial---begin");

    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);

    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);// 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
    });

    NSLog(@"asyncSerial---end");
}

打印：
[17313:4203018] currentThread—-{number = 1, name = main}
[17313:4203018] asyncSerial—-begin
[17313:4203018] asyncSerial—-end
[17313:4203079] 1—-{number = 3, name = (null)}
[17313:4203079] 2—-{number = 3, name = (null)}
[17313:4203079] 3—-{number = 3, name = (null)}

可以看到：

开启了一条新线程（异步执行具备开启新线程的能力，串行队列只开启一个线程）。

任务是按顺序执行的（串行队列每次只有一个任务被执行，任务一个接一个按顺序执行）。

同步执行 + 主队列

同步执行 + 主队列 在不同线程中调用结果也是不一样，在主线程中调用会发生死锁问题，而在其他线程中调用则不会。

在主线程中调用『同步执行 + 主队列』

/**
 * 同步执行 + 主队列
 * 特点(主线程调用)：互等卡主不执行。
 * 特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。
 */
- (void)syncMain {

    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"syncMain---begin");

    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_sync(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_sync(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_sync(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
    });

    NSLog(@"syncMain---end");
}

打印：
[17371:4213562] currentThread—-{number = 1, name = main}
[17371:4213562] syncMain—-begin
(lldb)

可以发现：

追加到主线程的任务 1、任务 2、任务 3 都不再执行了，而且 syncMain---end 也没有打印，还会直接报崩溃。这是为什么呢？

这是因为我们在主线程中执行 syncMain 方法，相当于把 syncMain 任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕，才会接着执行。那么当我们把任务 1 追加到主队列中，任务 1 就在等待主线程处理完 syncMain 任务。而syncMain 任务需要等待任务 1 执行完毕，才能接着执行。

那么，现在的情况就是 syncMain 任务和任务 1 都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且 syncMain---end 也没有打印。

在其他线程中调用『同步执行 + 主队列』

// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程，并自动启动线程执行 selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];

打印：
[17482:4237818] currentThread—-{number = 3, name = (null)}
[17482:4237818] syncMain—-begin
[17482:4237594] 1—-{number = 1, name = main}
[17482:4237594] 2—-{number = 1, name = main}
[17482:4237594] 3—-{number = 1, name = main}
[17482:4237818] syncMain—-end

可看到：

所有任务都是在主线程（非当前线程）中执行的，没有开启新的线程（所有放在主队列中的任务，都会放到主线程中执行）。所有任务都在打印的 syncConcurrent---begin 和 syncConcurrent---end 之间执行（同步任务需要等待队列的任务执行结束）。任务是按顺序执行的（主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

为什么现在就不会卡住了呢？

因为syncMain 任务放到了其他线程里，而任务 1、任务 2、任务3 都在追加到主队列中，这三个任务都会在主线程中执行。 syncMain 任务在其他线程中执行到追加任务 1 到主队列中，因为主队列现在没有正在执行的任务，所以，会直接执行主队列的任务1，等任务1 执行完毕，再接着执行任务 2、任务 3。所以这里不会卡住线程，也就不会造成死锁问题。

异步执行 + 主队列

/**
 * 异步执行 + 主队列
 * 特点：只在主线程中执行任务，执行完一个任务，再执行下一个任务
 */
- (void)asyncMain {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"asyncMain---begin");

    dispatch_queue_t queue = dispatch_get_main_queue();

    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);// 打印当前线程
    });

    dispatch_async(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程
    });

    NSLog(@"asyncMain---end");
}

打印：
[17521:4243690] currentThread—-{number = 1, name = main}
[17521:4243690] asyncMain—-begin
[17521:4243690] asyncMain—-end
[17521:4243690] 1—-{number = 1, name = main}
[17521:4243690] 2—-{number = 1, name = main}
[17521:4243690] 3—-{number = 1, name = main}

可以看到：

所有任务都是在当前线程（主线程）中执行的，并没有开启新的线程（虽然异步执行具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中）。

任务是按顺序执行的（因为主队列是串行队列，每次只有一个任务被执行，任务一个接一个按顺序执行）。

补充：为什么一定要在主线程更新UI呢？

首先，UIKit不是线程安全的，当多个线程同时操作UI时，抢夺资源，有可能导致崩溃，UI异常等问题。假如在两个线程中设置了同一张背景图片，很有可能就会由于背景图片被释放两次，使得程序崩溃。或者某一个线程中遍历找寻某个subView，然而在另一个线程中删除了该subView，那么就会造成错乱。

那么为什么不将UIKit设计成线程安全的呢？为了性能和效率。

多线程访问必定会涉及线程同步的开销问题，UIKit是一个庞大的框架，UI操作涉及到渲染访问各种View对象的属性，如果为了确保UI操作的线程安全，一来会带来巨大的成本（视图层级深，属性多），二来会耗费大量的资源拖慢运行速度（加锁）。这未必会带来更高的效率。

所以，UI的操作最好在单一线程里执行，那放到哪个线程呢？

在Cocoa Touch框架中，UIApplication初始化工作是在主线程进行的，而界面上所有的视图都是在UIApplication实例的叶子节点上（内存管理角度），所以所有的用户交互事件都是在主线程上进行传递，在主线程响应。在主线程操作UI，能够帮助我们避免一些不必要的麻烦和缺陷，也就成了一个约定俗成的开发规则。

那么，子线程到底能不能更新UI呢？

有时也可以，但是会有问题。在子线程能更新的UI是一个假象，其实是子线程代码执行完毕了，又自动进入到了主线程，执行了子线程中的UI更新的函数栈，这中间的时间非常的短，就让大家误以为分线程可以更新UI。如果子线程一直在运行，则子线程中的UI更新的函数栈，主线程就无法获知，那就无法更新直到子线程结束。

高级用法

栅栏函数：dispatch_barrier_async/sync

我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async 方法在两个操作组间形成栅栏。

dispatch_barrier_async 方法会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在 dispatch_barrier_async 方法追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行。具体如下图所示：

/** 栅栏方法 dispatch_barrier_async */
- (void)barrier {
    dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);

    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]);  // 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); //打印当前线程
    });

    dispatch_barrier_async(queue, ^{
        // 追加任务 barrier
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"barrier---%@",[NSThread currentThread]);//打印当线程
    });

    dispatch_async(queue, ^{
        // 追加任务 3
        [NSThread sleepForTimeInterval:2];// 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程
    });
    dispatch_async(queue, ^{
        // 追加任务 4
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"4---%@",[NSThread currentThread]);// 打印当前线程
    });
}

打印：
[17648:4262933] 1—-{number = 3, name = (null)}
[17648:4262932] 2—-{number = 4, name = (null)}
[17648:4262933] barrier—-{number = 3, name = (null)}
[17648:4262932] 4—-{number = 4, name = (null)}
[17648:4262933] 3—-{number = 3, name = (null)}

在 dispatch_barrier_async 执行结果中可以看出：

在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作。

补充一下dispatch_barrier_async：

对于自定义的并发队列，会按照上面的顺序执行，但是如果是系统的全局并发队列dispatch_queue_t queue = dispatch_get_global_queue(0, 0);，就不是这个顺序了,他们四个任务的顺序是不确定的；

如果要想按照自己的顺序来，最好还是自己自己创建一个并发队列。至于为什么，目前我也不是很清楚？

GCD 延时执行方法：dispatch_after

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 2.0 秒后异步追加任务代码到主队列，并开始执行
        NSLog(@"after---%@",[NSThread currentThread]);  
 });

GCD 一次性代码（只执行一次）：dispatch_once

我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 方法。

使用 dispatch_once 方法能保证某段代码在程序运行过程中只被执行 1 次，并且即使在多线程的环境下，dispatch_once 也可以保证线程安全。

- (void)once {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 只执行 1 次的代码（这里面默认是线程安全的）
    });
}

GCD 快速迭代方法：dispatch_apply

通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的方法 dispatch_apply。

dispatch_apply 按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。

如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。但是这样就体现不出快速迭代的意义了。

我们可以利用并发队列进行异步执行。比如说遍历 0~5 这 6 个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以在多个线程中同时（异步）遍历多个数字。

还有一点，无论是在串行队列，还是并发队列中，dispatch_apply 都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。

- (void)apply {
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    NSLog(@"apply---begin");
    dispatch_apply(6, queue, ^(size_t index) {
        NSLog(@"%zd---%@",index, [NSThread currentThread]);
    });
    NSLog(@"apply---end");
}

打印：
[17771:4285619] apply—-begin
[17771:4285619] 0—-{number = 1, name = main}
[17771:4285722] 1—-{number = 3, name = (null)}
[17771:4285720] 3—-{number = 5, name = (null)}
[17771:4285721] 2—-{number = 7, name = (null)}
[17771:4285719] 4—-{number = 6, name = (null)}
[17771:4285728] 5—-{number = 4, name = (null)}
[17771:4285619] apply—-end

因为是在并发队列中异步执行任务，所以各个任务的执行时间长短不定，最后结束顺序也不定。但是 apply---end 一定在最后执行。这是因为 dispatch_apply 方法会等待全部任务执行完毕。

GCD 队列组：dispatch_group

有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。

调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合来实现 dispatch_group_async。
调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait 回到当前线程继续向下执行（会阻塞当前线程）。

dispatch_group_notify

监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务

- (void)groupNotify {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"group---begin");

    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步任务 1、任务 2 都执行完毕后，回到主线程执行下边任务
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程

        NSLog(@"group---end");
    });
}

打印：
[17813:4293874] currentThread—-{number = 1, name = main}
[17813:4293874] group—-begin
[17813:4294048] 2—-{number = 4, name = (null)}
[17813:4294053] 1—-{number = 3, name = (null)}
[17813:4293874] 3—-{number = 1, name = main}
[17813:4293874] group—-end

从 dispatch_group_notify 相关代码运行输出结果可以看出：当所有任务都执行完成之后，才执行 dispatch_group_notify 相关 block 中的任务。

dispatch_group_wait

暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。

- (void)groupWait {
    NSLog(@"currentThread---%@",[NSThread currentThread]); 
    NSLog(@"group---begin");

    dispatch_group_t group =  dispatch_group_create();

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
    });

    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
    });

    // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

    NSLog(@"group---end");

}

打印：
[17844:4299926] currentThread—-{number = 1, name = main}
[17844:4299926] group—-begin
[17844:4300046] 2—-{number = 4, name = (null)}
[17844:4300043] 1—-{number = 3, name = (null)}
[17844:4299926] group—-end

从 dispatch_group_wait 相关代码运行输出结果可以看出：当所有任务执行完成之后，才执行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 会阻塞当前线程。

dispatch_group_enter、dispatch_group_leave

dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数 +1
dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数 -1。
当 group 中未执行完毕任务数为0的时候，才会使 dispatch_group_wait 解除阻塞，以及执行追加到 dispatch_group_notify 中的任务。

- (void)groupEnterAndLeave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"group---begin");

    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务 1
        [NSThread sleepForTimeInterval:2];  // 模拟耗时操作
        NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程

        dispatch_group_leave(group);
    });

    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        // 追加任务 2
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"2---%@",[NSThread currentThread]);// 打印当前线程

        dispatch_group_leave(group);
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程.
        [NSThread sleepForTimeInterval:2];   // 模拟耗时操作
        NSLog(@"3---%@",[NSThread currentThread]);// 打印当前线程

        NSLog(@"group---end");
    });
}

打印：
[17924:4314716] currentThread—-{number = 1, name = main}
[17924:4314716] group—-begin
[17924:4314816] 2—-{number = 3, name = (null)}
[17924:4314808] 1—-{number = 4, name = (null)}
[17924:4314716] 3—-{number = 1, name = main}
[17924:4314716] group—-end

从 dispatch_group_enter、dispatch_group_leave 相关代码运行结果中可以看出：

当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。这里的dispatch_group_enter、dispatch_group_leave 组合，其实等同于dispatch_group_async。

GCD 信号量：dispatch_semaphore

GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。

类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在 Dispatch Semaphore 中，使用计数来完成这个功能，计数小于 0 时等待，不可通过。计数为 0 或大于 0 时，计数减 1 且不等待，可通过。

Dispatch Semaphore 提供了三个方法：

dispatch_semaphore_create：创建一个 Semaphore 并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加 1
dispatch_semaphore_wait：可以使总信号量减 1，信号总量小于 0 时就会一直等待（阻塞所在线程），否则就可以正常执行。

注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。

Dispatch Semaphore 在实际开发中主要用于：

保持线程同步，将异步执行任务转换为同步执行任务
保证线程安全，为线程加锁

补充一点：使用信号量可能会造成线程优先级反转，且无法避免

iOS信号量造成线程优先级反转

Dispatch Semaphore 线程同步

需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。

/**
 * 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);
}

打印：
[17988:4325744] currentThread—-{number = 1, name = main}
[17988:4325744] semaphore—-begin
[17988:4325867] 1—-{number = 3, name = (null)}
[17988:4325744] semaphore—-end,number = 100

从 Dispatch Semaphore 实现线程同步的代码可以看到：

semaphore---end 是在执行完 number = 100; 之后才打印的。而且输出结果 number 为 100。这是因为 异步执行 不会做任何等待，可以继续执行任务。

执行顺如下：
1. semaphore 初始创建时计数为 0。
2. 异步执行 将 任务 1 追加到队列之后，不做等待，接着执行 dispatch_semaphore_wait 方法，semaphore 减 1，此时 semaphore == -1，当前线程进入等待状态。
3. 然后，异步任务 1 开始执行。任务 1 执行到 dispatch_semaphore_signal 之后，总信号量加 1，此时 semaphore == 0，正在被阻塞的线程（主线程）恢复继续执行。
4. 最后打印 semaphore---end,number = 100。

这样就实现了线程同步，将异步执行任务转换为同步执行任务。

Dispatch Semaphore 线程安全和线程同步（为线程加锁）

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。

线程同步：可理解为线程 A 和线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

举个简单例子就是：两个人在一起聊天。两个人不能同时说话，避免听不清(操作冲突)。等一个人说完(一个线程结束操作)，另一个再说(另一个线程再开始操作)。

下面，我们模拟火车票售卖的方式，实现 NSThread 线程安全和解决线程同步问题。

/**
 * 线程安全：使用 semaphore 加锁
 * 初始化火车票数量、卖票窗口（线程安全）、并开始卖票
 */
- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);  
    NSLog(@"semaphore---begin");

    semaphoreLock = dispatch_semaphore_create(1);

    self.ticketSurplusCount = 50;

    // queue1 代表北京火车票售卖窗口
    dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
    // queue2 代表上海火车票售卖窗口
    dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);

    __weak typeof(self) weakSelf = self;
    dispatch_async(queue1, ^{
        [weakSelf saleTicketSafe];
    });

    dispatch_async(queue2, ^{
        [weakSelf saleTicketSafe];
    });
}

/**
 * 售卖火车票（线程安全）
 */
- (void)saleTicketSafe {
    while (1) {
        // 相当于加锁
        dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);

        if (self.ticketSurplusCount > 0) {  // 如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数：%d 窗口：%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else { // 如果已卖完，关闭售票窗口
            NSLog(@"所有火车票均已售完");

            // 相当于解锁
            dispatch_semaphore_signal(semaphoreLock);
            break;
        }

        // 相当于解锁
        dispatch_semaphore_signal(semaphoreLock);
    }
}

打印：
[18116:4348091] currentThread—-{number = 1, name = main}
[18116:4348091] semaphore—-begin
[18116:4348159] 剩余票数：49 窗口：{number = 3, name = (null)}
[18116:4348157] 剩余票数：48 窗口：{number = 4, name = (null)}
[18116:4348159] 剩余票数：47 窗口：{number = 3, name = (null)}
…
[18116:4348157] 剩余票数：2 窗口：{number = 4, name = (null)}
[18116:4348159] 剩余票数：1 窗口：{number = 3, name = (null)}
[18116:4348157] 剩余票数：0 窗口：{number = 4, name = (null)}
[18116:4348159] 所有火车票均已售完`
[18116:4348157] 所有火车票均已售完

考虑了线程安全的情况下，使用 dispatch_semaphore机制之后，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。

NSOperation

NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。

为什么要使用 NSOperation、NSOperationQueue？

1、可添加完成的代码块，在操作完成后执行

2、添加操作之间的依赖关系，方便的控制执行顺序。

3、设定操作执行的优先级。

4、可以很方便的取消一个操作的执行。

5、使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled。

既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作）和队列（操作队列）的概念。

操作（Operation）

1、执行操作的意思，换句话说就是你在线程中执行的那段代码
2、在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作

操作队列（Operation Queues）

1、这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
2、操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行
3、NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

NSOperation常用属性和方法

1、开始取消操作
- - (void)start：对于并发Operation需要重写该方法，也可以不把operation加入到队列中，手动触发执行，与调用普通方法一样
- - (void)main：非并发Operation需要重写该方法
- - (void)cancel：可取消操作，实质是标记 isCancelled 状态
2、判断操作状态方法
- - (BOOL)isFinished; 判断操作是否已经结束
- - (BOOL)isCancelled 判断操作是否已经标记为取消
- - (BOOL)isExecuting;判断操作是否正在在运行
- - (BOOL)isReady;判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。
3、操作同步
- - (void)waitUntilFinished;阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步
- - (void)setCompletionBlock:(void (^)(void))block; 会在当前操作执行完毕时执行 completionBlock
- - (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成
- - (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
- @property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

NSOperationQueue 常用属性和方法

1、取消/暂停/恢复操作
- - (void)cancelAllOperations; 可以取消队列的所有操作
- - (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态
- - (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列
2、操作同步
- - (void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
3、添加/获取操作
- - (void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象
- - (void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait;向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束
- - (NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）
- - (NSUInteger)operationCount; 当前队列中的操作数
4、获取队列
- + (id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
- + (id)mainQueue; 获取主队列。

NSOperation 和 NSOperationQueue 基本使用

1、创建操作

NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们有三种方式来封装操作。

使用子类 NSInvocationOperation
使用子类 NSBlockOperation
自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。

在不使用 NSOperationQueue，单独使用 NSOperation 的情况下系统同步执行操作，下面我们学习以下操作的三种创建方式。

使用子类 `NSInvocationOperation`

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

    // 1.创建 NSInvocationOperation 对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];

    // 2.调用 start 方法开始执行操作
    [op start];
}

- (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }
}

打印：
1---<NSThread: 0x61800006ac40>{number = 1,name = main}
1---<NSThread: 0x61800006ac40>{number = 1,name = main}

可以看到：在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

但如果在其他线程中执行操作，则打印结果为其他线程。

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

打印：
1---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
1---<NSThread: 0x61800006ac40>{number = 3,name = (null)}

可以看到：在其他线程中单独使用子类 NSInvocationOperation，操作是在当前调用的其他线程执行的，并没有开启新线程。

使用子类 `NSBlockOperation`

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

    // 1.创建 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]);//打印当前线程
        }
    }];

    // 2.调用 start 方法开始执行操作
    [op start];
}

打印：
1---<NSThread: 0x61800006ac40>{number = 1,name = main}
1---<NSThread: 0x61800006ac40>{number = 1,name = main}

可以看到：在没有使用 NSOperationQueue、在主线程中单独使用 NSBlockOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

注意：和上边 NSInvocationOperation 使用一样。因为代码是在主线程中调用的，所以打印结果为主线程。如果在其他线程中执行操作，则打印结果为其他线程。

但是，NSBlockOperation 还提供了一个方法 addExecutionBlock:，通过 addExecutionBlock: 就可以为 NSBlockOperation 添加额外的操作。这些操作（包括 blockOperationWithBlock 中的操作）可以在不同的线程中同时（并发）执行。只有当所有相关的操作已经完成执行时，才视为完成。

如果添加的操作多的话，blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行，这是由系统决定的，并不是说添加到 blockOperationWithBlock: 中的操作一定会在当前线程中执行。（可以使用 addExecutionBlock: 多添加几个操作试试）。

/**
 * 使用子类 NSBlockOperation
 * 调用方法 AddExecutionBlock:
 */
- (void)useBlockOperationAddExecutionBlock {

    // 1.创建 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]);//打印当前线程
        }
    }];

    // 2.添加额外的操作
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"5---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"6---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"7---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"8---%@", [NSThread currentThread]);//打印当前线程
        }
    }];

    // 3.调用 start 方法开始执行操作
    [op start];
}

打印：
8---<NSThread: 0x61800006ac40>{number = 9,name = (null)}
5---<NSThread: 0x61800006ac40>{number = 6,name = (null)}
6---<NSThread: 0x61800006ac40>{number = 8,name = (null)}
1---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
3---<NSThread: 0x61800006ac40>{number = 1,name = main}
2---<NSThread: 0x61800006ac40>{number = 5,name = (null)}
4---<NSThread: 0x61800006ac40>{number = 4,name = (null)}
7---<NSThread: 0x61800006ac40>{number = 7,name = (null)}
3---<NSThread: 0x61800006ac40>{number = 1,name = main}
1---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
2---<NSThread: 0x61800006ac40>{number = 5,name = (null)}
8---<NSThread: 0x61800006ac40>{number = 9,name = (null)}
6---<NSThread: 0x61800006ac40>{number = 8,name = (null)}
5---<NSThread: 0x61800006ac40>{number = 6,name = (null)}
4---<NSThread: 0x61800006ac40>{number = 4,name = (null)}
7---<NSThread: 0x61800006ac40>{number = 7,name = (null)}

可以看出：使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。而且，这次执行结果中 blockOperationWithBlock:方法中的操作也不是在当前线程（主线程）中执行的。从而印证了blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行。

一般情况下，如果一个 NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。

使用自定义继承自 NSOperation 的子类

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。

可以通过重写 main 或者 start 方法来定义自己的 NSOperation 对象。

重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操作就结束了。

先定义一个继承自 NSOperation 的子类，重写main方法。

#import <Foundation/Foundation.h>

@interface YSCOperation : NSOperation

@end

#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

然后使用的时候导入头文件YSCOperation.h。
/**
 * 使用自定义继承自 NSOperation 的子类
 */
- (void)useCustomOperation {
    // 1.创建 YSCOperation 对象
    YSCOperation *op = [[YSCOperation alloc] init];
    // 2.调用 start 方法开始执行操作
    [op start];
}

打印：
1---<NSThread: 0x61800006ac40>{number = 1,name = main}
1---<NSThread: 0x61800006ac40>{number = 1,name = main}

可以看出：在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程。

创建队列

NSOperationQueue 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。下边是主队列、自定义队列的基本创建方法和特点。

主队列

凡是添加到主队列中的操作，都会放到主线程中执行。

// 主队列获取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];

自定义队列（非主队列）

添加到这种队列中的操作，就会自动放到子线程中执行。
同时包含了：串行、并发功能。

// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

将操作加入到队列中

- (void)addOperation:(NSOperation *)op;

需要先创建操作，再将创建好的操作加入到创建好的队列中去。

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

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

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

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

    // 使用 NSBlockOperation 创建操作3
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [op3 addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]);//打印当前线程
        }
    }];

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

打印：
4---<NSThread: 0x61800006ac40>{number = 6,name = (null)}
2---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
1---<NSThread: 0x61800006ac40>{number = 5,name = (null)}
3---<NSThread: 0x61800006ac40>{number = 4,name = (null)}
1---<NSThread: 0x61800006ac40>{number = 5,name = (null)}
2---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
3---<NSThread: 0x61800006ac40>{number = 4,name = (null)}
4---<NSThread: 0x61800006ac40>{number = 6,name = (null)}

可以看出：使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。

- (void)addOperationWithBlock:(void (^)(void))block;

无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。

/**
 * 使用 addOperationWithBlock: 将操作加入到操作队列中
 */

- (void)addOperationWithBlockToQueue {
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.使用 addOperationWithBlock: 添加操作到队列中
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
}

打印：
2---<NSThread: 0x61800006ac40>{number = 4,name = (null)}
3---<NSThread: 0x61800006ac40>{number = 5,name = (null)}
1---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
3---<NSThread: 0x61800006ac40>{number = 5,name = (null)}
1---<NSThread: 0x61800006ac40>{number = 3,name = (null)}
2---<NSThread: 0x61800006ac40>{number = 4,name = (null)}

可以看出：使用 addOperationWithBlock: 将操作加入到操作队列后能够开启新线程，进行并发执行。

NSOperationQueue 控制串行执行、并发执行

这里有个关键属性 maxConcurrentOperationCount，叫做最大并发操作数。用来控制一个特定队列中可以有多少个操作同时参与并发执行。

注意：这里 maxConcurrentOperationCount 控制的不是并发线程的数量，而是一个队列中同时能并发执行的最大操作数。而且一个操作也并非只能在一个线程中运行。

最大并发操作数：maxConcurrentOperationCount

maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。
maxConcurrentOperationCount 大于1时，队列为并发队列。操作并发执行，当然这个值不应超过系统限制，即使自己设置一个很大的值，系统也会自动调整为 min{自己设定的值，系统设定的默认最大值。

/**
 * 设置 MaxConcurrentOperationCount（最大并发操作数）
 */
- (void)setMaxConcurrentOperationCount {

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.设置最大并发操作数
    queue.maxConcurrentOperationCount = 1; // 串行队列
// queue.maxConcurrentOperationCount = 2; // 并发队列
// queue.maxConcurrentOperationCount = 8; // 并发队列

    // 3.添加操作
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    [queue addOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
}

打印：

最大并发操作数为1 输出结果：
1---{number = 3,name = (null)}
1---{number = 3,name = (null)}
2---{number = 4,name = (null)}
2---{number = 4,name = (null)}
3---{number = 3,name = (null)}
3---{number = 3,name = (null)}
4---{number = 4,name = (null)}
4---{number = 4,name = (null)}

最大并发操作数为2 输出结果：
1---{number = 3,name = (null)}
2---{number = 4,name = (null)}
2---{number = 4,name = (null)}
1---{number = 3,name = (null)}
4---{number = 5,name = (null)}
3---{number = 6,name = (null)}
4---{number = 5,name = (null)}
3---{number = 6,name = (null)}

可以看出：当最大并发操作数为1时，操作是按顺序串行执行的，并且一个操作完成之后，下一个操作才开始执行。当最大操作并发数为2时，操作是并发执行的，可以同时执行两个操作。而开启线程数量是由系统决定的，不需要我们来管理。

NSOperation 操作依赖

通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序。NSOperation 提供了3个接口供我们管理和查看依赖。

- (void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
- (void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

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

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 2.创建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]);//打印当前线程
        }
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]);//打印当前线程
        }
    }];

    // 3.添加依赖
    [op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2

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

打印：
1---{number = 3,name = (null)}
1---{number = 3,name = (null)}
2---{number = 4,name = (null)}
2---{number = 4,name = (null)}

可以看到：通过添加操作依赖，无论运行几次，其结果都是 op1 先执行，op2 后执行。

NSOperation 优先级

NSOperation 提供了queuePriority（优先级）属性，queuePriority属性适用于同一操作队列中的操作，不适用于不同操作队列中的操作。默认情况下，所有新创建的操作对象优先级都是NSOperationQueuePriorityNormal。但是我们可以通过setQueuePriority:方法来改变当前操作在同一队列中的执行优先级。

// 优先级的取值
typedef NS_ENUM(NSInteger, NSOperationQueuePriority) {
    NSOperationQueuePriorityVeryLow = -8L,
    NSOperationQueuePriorityLow = -4L,
    NSOperationQueuePriorityNormal = 0,
    NSOperationQueuePriorityHigh = 4,
    NSOperationQueuePriorityVeryHigh = 8
}

对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的 开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。

那么，什么样的操作才是进入就绪状态的操作呢？

当一个操作的所有依赖都已经完成时，操作对象通常会进入准备就绪状态，等待执行。

举个例子，现在有4个优先级都是 NSOperationQueuePriorityNormal（默认级别）的操作：op1，op2，op3，op4。其中 op3 依赖于 op2，op2 依赖于 op1，即 op3 -> op2 -> op1。现在将这4个操作添加到队列中并发执行。

因为 op1 和 op4 都没有需要依赖的操作，所以在 op1，op4 执行之前，就是出于准备就绪状态的操作。
而 op3 和 op2 都有依赖的操作，所以 op3 和 op2 都不是准备就绪状态下的操作。

理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象。

queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。
如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。
如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

NSOperation、NSOperationQueue 线程间的通信

/**
 * 线程间通信
 */
- (void)communication {

    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    // 2.添加操作
    [queue addOperationWithBlock:^{
        // 异步进行耗时操作
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]);//打印当前线程
        }

        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // 进行一些 UI 刷新等操作
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
                NSLog(@"2---%@", [NSThread currentThread]);//打印当前线程
            }
        }];
    }];
}

打印：
1---{number = 3,name = (null)}
1---{number = 3,name = (null)}
2---{number = 1,name = main}
2---{number = 1,name = main}

可以看到：通过线程间的通信，先在其他线程中执行操作，等操作执行完了之后再回到主线程执行主线程的相应操作。

NSOperation、NSOperationQueue 线程同步和线程安全

线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程同步：可理解为线程 A 和线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续操作。

NSOperation、NSOperationQueue 线程安全

线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。

iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。

这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。

/**
 * 线程安全：使用 NSLock 加锁
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */

- (void)initTicketStatusSave {
    NSLog(@"currentThread---%@",[NSThread currentThread]);//打印当前线程

    self.ticketSurplusCount = 50;

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

    // 1.创建 queue1,queue1 代表北京火车票售卖窗口
    NSOperationQueue *queue1 = [[NSOperationQueue alloc] init];
    queue1.maxConcurrentOperationCount = 1;

    // 2.创建 queue2,queue2 代表上海火车票售卖窗口
    NSOperationQueue *queue2 = [[NSOperationQueue alloc] init];
    queue2.maxConcurrentOperationCount = 1;

    // 3.创建卖票操作 op1
    __weak typeof(self) weakSelf = self;
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        [weakSelf saleTicketSafe];
    }];

    // 4.创建卖票操作 op2
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        [weakSelf saleTicketSafe];
    }];

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

/**
 * 售卖火车票(线程安全)
 */
- (void)saleTicketSafe {
    while (1) {

        // 加锁
        [self.lock lock];

        if (self.ticketSurplusCount > 0) {
            //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%d 窗口:%@", self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        }

        // 解锁
        [self.lock unlock];

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

打印：
[18116:4348091] currentThread—-{number = 1, name = main}
[18116:4348159] 剩余票数：49 窗口：{number = 3, name = (null)}
[18116:4348157] 剩余票数：48 窗口：{number = 4, name = (null)}
[18116:4348159] 剩余票数：47 窗口：{number = 3, name = (null)}
…
[18116:4348157] 剩余票数：2 窗口：{number = 4, name = (null)}
[18116:4348159] 剩余票数：1 窗口：{number = 3, name = (null)}
[18116:4348157] 剩余票数：0 窗口：{number = 4, name = (null)}
[18116:4348159] 所有火车票均已售完
[18116:4348157] 所有火车票均已售完

可以看出：在考虑了线程安全，使用 NSLock 加锁、解锁机制的情况下，得到的票数是正确的，没有出现混乱的情况。我们也就解决了多个线程同步的问题。

关于线程安全的问题，就是用锁来解决了，稍后再文章分享。

线程的互相通信

在 iOS 开发过程中，一般在主线程里边进行 UI 刷新，例如：点击、滚动、拖拽等事件。通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。

gcd

- (void)communication {
    // 获取全局并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
    // 获取主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue(); 

    dispatch_async(queue, ^{
        // 异步追加任务
        for (int i = 0; i < 2; ++i) {
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"1---%@",[NSThread currentThread]);      // 打印当前线程
        }

        // 回到主线程
        dispatch_async(mainQueue, ^{
            // 追加在主线程中执行的任务
            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作
            NSLog(@"2---%@",[NSThread currentThread]);      // 打印当前线程
        });
    });
}

NSThread

// 在主线程上执行操作
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray<NSString *> *)array;
// equivalent to the first method with kCFRunLoopCommonModes

// 在指定线程上执行操作
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait modes:(NSArray *)array NS_AVAILABLE(10_5, 2_0);
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait NS_AVAILABLE(10_5, 2_0);

// 在当前线程上执行操作，调用 NSObject 的 performSelector:相关方法
- (id)performSelector:(SEL)aSelector;
- (id)performSelector:(SEL)aSelector withObject:(id)object;
- (id)performSelector:(SEL)aSelector withObject:(id)object1 withObject:(id)object2;

NSOperation

- (void)communication
{
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    [queue addOperationWithBlock:^{
        // 异步进行耗时操作
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }

        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // 进行一些 UI 刷新等操作
            for (int i = 0; i < 2; i++) {
                [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
                NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
            }
        }];
    }];
}
打印：
1---<NSThread: 0x60000047dcc0>{number = 3, name = (null)}
1---<NSThread: 0x60000047dcc0>{number = 3, name = (null)}
2---<NSThread: 0x600000067c80>{number = 1, name = main}
2---<NSThread: 0x600000067c80>{number = 1, name = main}

以上若有错误，欢迎指正。转载请注明出处。