基本概念

进程

在系统中正在运行的一个应用程序
每个进程之间是独立的,它们均运行在其专用且受保护的内存空间内.若你此时打开了微信,又打开了QQ音乐,则系统会分别启动两个进程.
iOS开发都是单进程,安卓可以支持多进程
进程可以控制很多条线程来执行相应的任务
进程至少要有一条线程,用来执行任务

线程

是进程的基本执行单元,1个进程若想执行任务,至少要有一个线程
系统会默认开启一条线程,称为主线程或UI线程
线程上的任务执行完毕后,线程会自动销毁
但是开辟线程要耗费一定的内存空间,会耗时,异步不会堵塞线程,会先执行下面的语句,就是因为辟线程耗时了
我们开辟线程时有时会给他们命名,这样是为了打断点调试时能看到调用的堆栈信息

主线程

处理UI，所有更新UI的操作都必须在主线程上执行。不要把耗时操作放在主线程，界面会卡。

多线程

在同一时刻，一个CPU只能处理1条线程，但CPU可以在多条线程之间快速的切换，只要切换的足够快，就造成了多线程一同执行的假象。

同步和异步

同步：在当前线程中执行任务，不具备开启新线程的能力；
异步：在新的线程中执行任务,具备开启新线程的能力；
同步函数(dispatch中的sync函数)：
- 在当前线程中执行队列里面的任务，不具备开启线程的能力；
- 立马在当前线程执行任务，执行完毕后才能继续往下执行
- 阻塞当前线程，即同步函数内的任务不执行完，该函数就会卡住，不会继续往下执行；
异步函数(dispatch中的async函数)：
- 在新的线程中执行队列里面的任务，具备开启线程的能力；
- 不阻塞当前线程，不用管当前的任务是否完成，都会往下执行；
- 会有一段时间去执行线程中的任务，因此后面的任务可能会在它之前执行；

串行和并发

串行队列(DISPATCH_QUEUE_SERIAL )：一个任务执行完成后,再执行下一个任务。
并发队列(DISPATCH_QUEUE_CONCURRENT)：多个任务并发(同时)执行；

进程和线程的区别

地址空间
进程之间是独立的地址空间,但同一进程的线程共享本进程的地址空间
资源拥有
进程之间的资源是独立的,但同一进程的线程共享本进程的资源(如内存,I/O,cpu等)
线程是处理器调度的基本单位,但进程不是,意思是CPU调度是调度线程
执行过程
进程可以独立执行,每个独立的进程都有一个程序运行的入口
线程不能独立执行,必须存活在应用程序中
崩溃
进程崩溃时,对其他进程没有影响
线程崩溃时,整个进程就死掉了
多进程比多线程健壮

多线程

多线程的原理：
CPU在单位时间片里快速的在各个线程之间切换
多线程的意义：

优点：

提高执行效率
提高资源(CPU,内存)利用率
线程执行完任务后,会自动销毁

缺点：

开启线程需要占用一定的内存空间,进行耗时
线程越多,耗时越多,会降低程序的性能,也会增大CPU在调用线程上的开销
程序设计会更加复杂,比如线程间的通信,多线程的数据共享

实现多线程的几种方式

Pthread
NSThread
GCD
NSOperation

NSThread

优缺点

优点：NSThread比其他两个轻量级；
缺点：需要自己管理线程的生命周期，线程同步，线程同步时对数据的加锁会有一定的系统开销。

NSThread的使用

优点：NSThread比其他两个轻量级；
缺点：需要自己管理线程的生命周期，线程同步，线程同步时对数据的加锁会有一定的系统开销。

实例方法创建NSThread

实例方法创建的NSThread对象，我们需要手动调用方法[thread start]来启动线程，实际上都是开辟了一个子线程。

- (void)demo{
    //第一种方法：block方式
    NSThread * thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    [thread start];
    
    //第二种方法：SEL方式
    NSThread * thread1 = [[NSThread alloc] initWithBlock:^{
        NSLog(@"%@",[NSThread currentThread]);
    }];
    [thread1 start];
}
- (void)run{
    NSLog(@"%@",[NSThread currentThread]);
}

*********打印结果********
2020-08-13 15:19:24.874162+0800 OC-多线程之NSThread[43983:2668593] <NSThread: 0x600002269a80>{number = 6, name = (null)}
2020-08-13 15:19:24.874219+0800 OC-多线程之NSThread[43983:2668594] <NSThread: 0x600002269800>{number = 7, name = (null)}

2.类方法创建NSThread

//类方法创建
- (void)demo1{
    //block
    [NSThread detachNewThreadWithBlock:^{
        NSLog(@"%@",[NSThread currentThread]);
    }];
    
    //SEL
    [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
}

*********打印结果********
2020-08-13 15:24:21.931115+0800 OC-多线程之NSThread[44042:2672229] <NSThread: 0x600001314480>{number = 7, name = (null)}
2020-08-13 15:24:21.931220+0800 OC-多线程之NSThread[44042:2672230] <NSThread: 0x600001308a80>{number = 6, name = (null)}

3.NSThread的其他方法

//获取当前线程
@property (class, readonly, strong) NSThread *currentThread;

设置线程沉睡到指定日期
+ (void)sleepUntilDate:(NSDate *)date;
  
线程沉睡时间间隔，这个方法在设置启动页间隔的时候比较常见
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
  
线程退出，当执行到某一个特殊情况下的时候你可以退出当前的线程，注意不要在主线程随便调用
+ (void)exit;
  
线程的优先级
+ (double)threadPriority;
  
设置线程的优先级：取值范围0~1，值越大，执行越早
+ (BOOL)setThreadPriority:(double)p;
  

NSObject分类中创建线程的方法

除了上面的两种方式创建线程外，@interface NSObject (NSThreadPerformAdditions)这个NSObject分类别中也有一些创建线程的方法：
1）主线程执行任务

/*
在主线程执行任务
aSelector：一个选择器, 指定要调用的方法
arg：需要传递给调用方法的参数，如果没有需要的参数,传入nil
waitUntilDone：一个布尔值，指定是否阻塞当前线程直到指定选择器在主线程中执行完毕。选择YES会阻塞这个线程；选择NO，本方法会立刻返回。
modes：RunLoop的运行的类型
*/
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES modes:nil];
[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];

2)实际使用
例子1：

{
    [self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:NO];
    NSLog(@"1");
}
    
- (void)run{
    NSLog(@"%@",[NSThread currentThread]);
}

*******打印结果******
2020-08-13 23:11:39.640250+0800 OC-多线程之NSThread[45345:2800240] 1
2020-08-13 23:11:39.662218+0800 OC-多线程之NSThread[45345:2800240] <NSThread: 0x600001114480>{number = 1, name = main}

结论：waitUntilDone设置为NO，没有堵塞主线程，先打印1，后打印[NSThread currentThread]。

例子2：

[self performSelectorOnMainThread:@selector(run) withObject:nil waitUntilDone:YES];

如果将waitUntilDone设置为YES，堵塞主线程，先打印[NSThread currentThread]后打印1

指定线程执行

[self performSelector:@selector(run) onThread:[NSThread currentThread] withObject:nil waitUntilDone:NO];
[self  performSelector:@selector(run) onThread:[NSThread currentThread] withObject:nil waitUntilDone:NO modes:nil];

指定后台执行

//后台执行
[self performSelectorInBackground:@selector(run) withObject:nil];

开启了一个新的线程去执行任务

GCD

什么是GCD？

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的较新的解决方法。它主要用于优化应用程序以支持多核处理器以及其他对称多处理系统。它是一个在线程池模式的基础上执行的并行任务。

GCD的优点?

GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
GCD更接近底层，性能较高

NSOperation

NSOperation介绍

NSOperation是基于GCD开发的，是GCD更高一层的封装，比GCD拥有更强的可控性和代码可读性。
NSOperation是一个抽象基类，表示一个独立的计算单元，可以为子类提供有用且线程安全的建立状态，优先级，依赖和取消等操作。
我们使用比较多的就是它的子类NSInvocationOperation和NSBlockOperation。不过我们更多的使用是自己继承并定制自己的操作。

为什么要使用 NSOperation？

可添加完成的代码块，在操作完成后执行。
添加操作之间的依赖关系，方便的控制执行顺序。
设定操作执行的优先级。
可以很方便的取消一个操作的执行。
使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled。

NSOperation、NSOperationQueue 操作和操作队列

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

操作（Operation）

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

2.操作队列（Operation Queues）：

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

NSOperation、NSOperationQueue 使用介绍

NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们能更好的实现异步执行。
NSOperation 实现多线程的使用步骤分为三步：
- 创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
- 创建队列：创建 NSOperationQueue 对象。
- 将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。
之后呢，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。

NSOperation的基本使用

1.使用子类 NSInvocationOperation

在主线程执行

- (void)demo{
    //1.创建NSInvocationOperation 对象
    NSInvocationOperation * operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
    //2.调用 start 方法开始执行操作
    [operation start];
}

- (void)run{
    NSLog(@"%@",[NSThread currentThread]);
}

**********打印结果**********
2020-08-16 11:59:20.701876+0800 OC-NSOperation[1670:53602] <NSThread: 0x600003f28d40>{number = 1, name = main}

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

在子线程执行

- (void)demo{
    //3.在其他线程使用
    [NSThread detachNewThreadWithBlock:^{
        NSLog(@"1---%@",[NSThread currentThread]);
        //1.创建NSInvocationOperation 对象
        NSInvocationOperation * operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
        //2.调用 start 方法开始执行操作
        [operation start];
        
    }];
}

- (void)run{
    NSLog(@"2---%@",[NSThread currentThread]);
}

**********打印结果**********
2020-08-16 12:06:20.454733+0800 OC-NSOperation[1782:60475] 1---<NSThread: 0x600000cfe200>{number = 6, name = (null)}
2020-08-16 12:06:20.455356+0800 OC-NSOperation[1782:60475] 2---<NSThread: 0x600000cfe200>{number = 6, name = (null)}

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

2.使用子类 NSBlockOperation

在主线程使用

- (void)demo1{
    //1.创建 NSBlockOperation 对象
    NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        //打印当前线程
        NSLog(@"%@", [NSThread currentThread]);
    }];
    //2.调用 start 方法开始执行操作
    [operation start];
}

*********打印结果**********
2020-08-16 12:09:47.030187+0800 OC-NSOperation[1837:63421] <NSThread: 0x6000034b0380>{number = 1, name = main}

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

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

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

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

- (void)demo1{
    //1.创建 NSBlockOperation 对象
    NSBlockOperation * operation = [NSBlockOperation blockOperationWithBlock:^{
        //打印当前线程
        NSLog(@"%@", [NSThread currentThread]);
    }];
    
    //2.添加额外的操作
    [operation addExecutionBlock:^{
        //打印当前线程
        NSLog(@"1-%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        //打印当前线程
        NSLog(@"2-%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        //打印当前线程
        NSLog(@"3-%@", [NSThread currentThread]);
    }];
    [operation addExecutionBlock:^{
        //打印当前线程
        NSLog(@"4-%@", [NSThread currentThread]);
    }];
    
    
    //调用 start 方法开始执行操作
    [operation start];
}

**********打印结果********
2020-08-16 12:13:40.905153+0800 OC-NSOperation[1926:67565] 1-<NSThread: 0x6000032c4f80>{number = 4, name = (null)}
2020-08-16 12:13:40.905162+0800 OC-NSOperation[1926:67564] 2-<NSThread: 0x6000032be140>{number = 6, name = (null)}
2020-08-16 12:13:40.905168+0800 OC-NSOperation[1926:67563] 3-<NSThread: 0x6000032cd180>{number = 7, name = (null)}
2020-08-16 12:13:40.905186+0800 OC-NSOperation[1926:67504] <NSThread: 0x60000328c240>{number = 1, name = main}
2020-08-16 12:13:40.905385+0800 OC-NSOperation[1926:67565] 4-<NSThread: 0x6000032c4f80>{number = 4, name = (null)}

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

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

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

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。可以通过重写 main 或者 start 方法来定义自己的 NSOperation 对象。重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操作就结束了。

在主线程中使用
先定义一个继承自 NSOperation 的子类，重写main方法。
.h文件中

#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface ZJOperation : NSOperation

@end

.m文件中

#import "ZJOperation.h"

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

在其他类中使用

- (void)demo2{
    //1.创建ZJOperation对象
    ZJOperation * operation = [[ZJOperation alloc] init];
    //2.调用 start 方法开始执行操作
    [operation start];
}

*******打印结果******
2020-08-16 12:24:16.940268+0800 OC-NSOperation[2093:75334] ZJ---<NSThread: 0x600001994380>{number = 1, name = main}
2020-08-16 12:24:18.941867+0800 OC-NSOperation[2093:75334] ZJ---<NSThread: 0x600001994380>{number = 1, name = main}

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

在子线程中使用

- (void)demo2{
    //1.在子线程中使用
    [NSThread detachNewThreadWithBlock:^{
        NSLog(@"1---%@",[NSThread currentThread]);
        //1.创建ZJOperation对象
        ZJOperation * operation = [[ZJOperation alloc] init];
        //2.调用 start 方法开始执行操作
        [operation start];

    }];
}

*******打印结果******
2020-08-16 12:26:04.684475+0800 OC-NSOperation[2117:76849] 1---<NSThread: 0x600003fd6900>{number = 6, name = (null)}
2020-08-16 12:26:06.689546+0800 OC-NSOperation[2117:76849] ZJ---<NSThread: 0x600003fd6900>{number = 6, name = (null)}
2020-08-16 12:26:08.694929+0800 OC-NSOperation[2117:76849] ZJ---<NSThread: 0x600003fd6900>{number = 6, name = (null)}

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

NSOperationQueue的基本使用

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

主队列：凡是添加到主队列中的操作，都会放到主线程中执行（注：不包括操作使用addExecutionBlock:添加的额外操作，额外操作可能在其他线程执行，感谢指正）。

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

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

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

1.将操作加入到队列中

上边我们说到 NSOperation 需要配合 NSOperationQueue 来实现多线程。

那么我们需要将创建好的操作加入到队列中去。总共有两种方法：

1)- (void)addOperation:(NSOperation *)op;
需要先创建操作，再将创建好的操作加入到创建好的队列中去。

- (void)demo3{
    //1.创建队列
    NSOperationQueue * queue = [[NSOperationQueue alloc] init];
    
    // 2.创建操作
    // 使用 NSInvocationOperation 创建操作1
    NSInvocationOperation * op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];

    // 使用 NSBlockOperation 创建操作3
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        // 打印当前线程
        NSLog(@"2---%@", [NSThread currentThread]);
    }];
    [op2 addExecutionBlock:^{
        NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
    }];

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

- (void)run{
    NSLog(@"1---%@",[NSThread currentThread]);
}

*********打印操作*******
2020-08-16 12:37:09.954238+0800 OC-NSOperation[2180:82843] 2---<NSThread: 0x600002018d40>{number = 5, name = (null)}
2020-08-16 12:37:09.954238+0800 OC-NSOperation[2180:82848] 3---<NSThread: 0x60000201db40>{number = 3, name = (null)}
2020-08-16 12:37:09.954271+0800 OC-NSOperation[2180:82845] 1---<NSThread: 0x600002062d40>{number = 4, name = (null)}

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

2)- (void)addOperationWithBlock:(void (^)(void))block;
无需先创建操作，在 block 中添加操作，直接将包含操作的 block 加入到队列中。

- (void)demo4{
    //1.创建队列
    NSOperationQueue * queue = [[NSOperationQueue alloc] init];
    //2.使用 addOperationWithBlock: 添加操作到队列中
    [queue addOperationWithBlock:^{
        NSLog(@"1---%@",[NSThread currentThread]);
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"2---%@",[NSThread currentThread]);
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"3---%@",[NSThread currentThread]);
    }];
}

*********打印操作*******
2020-08-16 12:40:45.166909+0800 OC-NSOperation[2238:85786] 2---<NSThread: 0x60000291a680>{number = 5, name = (null)}
2020-08-16 12:40:45.166909+0800 OC-NSOperation[2238:85788] 1---<NSThread: 0x600002965400>{number = 3, name = (null)}
2020-08-16 12:40:45.166921+0800 OC-NSOperation[2238:85784] 3---<NSThread: 0x600002965540>{number = 6, name = (null)}

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

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

之前我们说过，NSOperationQueue 创建的自定义队列同时具有串行、并发功能，上边我们演示了并发功能，那么他的串行功能是如何实现的？

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

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

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

- (void)demo5{
    /*
     设置 MaxConcurrentOperationCount（最大并发操作数）
     */
    // 1.创建队列
    NSOperationQueue * queue = [[NSOperationQueue alloc] init];

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

    // 3.添加操作
    [queue addOperationWithBlock:^{
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
    }];
    
}

最大并发操作数为1 输出结果：

2020-08-16 12:48:09.090860+0800 OC-NSOperation[2324:91784] 1---<NSThread: 0x600002a2e780>{number = 4, name = (null)}
2020-08-16 12:48:09.091107+0800 OC-NSOperation[2324:91784] 2---<NSThread: 0x600002a2e780>{number = 4, name = (null)}
2020-08-16 12:48:09.091296+0800 OC-NSOperation[2324:91784] 3---<NSThread: 0x600002a2e780>{number = 4, name = (null)}
2020-08-16 12:48:09.091446+0800 OC-NSOperation[2324:91784] 4---<NSThread: 0x600002a2e780>{number = 4, name = (null)}

最大并发操作数为2 输出结果：

2020-08-16 12:48:24.421434+0800 OC-NSOperation[2338:92272] 2---<NSThread: 0x600001106780>{number = 6, name = (null)}
2020-08-16 12:48:24.421437+0800 OC-NSOperation[2338:92269] 1---<NSThread: 0x6000011066c0>{number = 5, name = (null)}
2020-08-16 12:48:24.421724+0800 OC-NSOperation[2338:92269] 4---<NSThread: 0x6000011066c0>{number = 5, name = (null)}
2020-08-16 12:48:24.421733+0800 OC-NSOperation[2338:92272] 3---<NSThread: 0x600001106780>{number = 6, name = (null)}

最大并发操作数为8 输出结果：

*******打印结果******8
2020-08-16 12:46:22.158690+0800 OC-NSOperation[2307:90480] 2---<NSThread: 0x6000024003c0>{number = 4, name = (null)}
2020-08-16 12:46:22.158727+0800 OC-NSOperation[2307:90478] 4---<NSThread: 0x60000240bb00>{number = 7, name = (null)}
2020-08-16 12:46:22.158737+0800 OC-NSOperation[2307:90482] 1---<NSThread: 0x600002408ac0>{number = 5, name = (null)}
2020-08-16 12:46:22.158760+0800 OC-NSOperation[2307:90485] 3---<NSThread: 0x600002418ac0>{number = 6, name = (null)}

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

3.NSOperationQueue 操作依赖

NSOperation、NSOperationQueue 最吸引人的地方是它能添加操作之间的依赖关系。通过操作依赖，我们可以很方便的控制操作之间的执行先后顺序。NSOperation 提供了3个接口供我们管理和查看依赖。

(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
(void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。
@property (readonly, copy) NSArray<NSOperation *> *dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。
当然，我们经常用到的还是添加依赖操作。现在考虑这样的需求，比如说有 A、B 两个操作，其中 A 执行完操作，B 才能执行操作。

如果使用依赖来处理的话，那么就需要让操作 B 依赖于操作 A。具体代码如下：

- (void)demo5{
    /*
     设置 MaxConcurrentOperationCount（最大并发操作数）
     */
    // 1.创建队列
    NSOperationQueue * queue = [[NSOperationQueue alloc] init];

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

    // 3.添加操作
    [queue addOperationWithBlock:^{
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [queue addOperationWithBlock:^{
        NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
    }];
    
}

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

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

    // 2.创建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }];
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
    }];

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

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

******打印结果*****
2020-08-16 12:52:02.556360+0800 OC-NSOperation[2376:94789] 1---<NSThread: 0x6000017fe000>{number = 5, name = (null)}
2020-08-16 12:52:02.556627+0800 OC-NSOperation[2376:94792] 2---<NSThread: 0x6000017f4ac0>{number = 6, name = (null)}

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

4.NSOperationQueue 优先级
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，op2 依赖于 op1），所以 op3 和 op2 都不是准备就绪状态下的操作。
理解了进入就绪状态的操作，那么我们就理解了queuePriority 属性的作用对象。
queuePriority 属性决定了进入准备就绪状态下的操作之间的开始执行顺序。并且，优先级不能取代依赖关系。
如果一个队列中既包含高优先级操作，又包含低优先级操作，并且两个操作都已经准备就绪，那么队列先执行高优先级操作。比如上例中，如果 op1 和 op4 是不同优先级的操作，那么就会先执行优先级高的操作。
如果，一个队列中既包含了准备就绪状态的操作，又包含了未准备就绪的操作，未准备就绪的操作优先级比准备就绪的操作优先级高。那么，虽然准备就绪的操作优先级低，也会优先执行。优先级不能取代依赖关系。如果要控制操作间的启动顺序，则必须使用依赖关系。

- (void)demo6{
    /*
        操作依赖
        使用方法：addDependency:
        优先级：setQueuePriority
     */

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

    // 2.创建操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [op1 setQueuePriority:NSOperationQueuePriorityLow];
    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [op2 setQueuePriority:NSOperationQueuePriorityVeryHigh];

    NSBlockOperation * op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
    }];
    [op3 setQueuePriority:NSOperationQueuePriorityHigh];
    
    // 3.添加依赖
    [op2 addDependency:op1]; // 让op2 依赖于 op1，则先执行op1，在执行op2

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


********打印结果*******
2020-08-16 13:38:09.628886+0800 OC-NSOperation[2556:109314] 3---<NSThread: 0x6000039d1880>{number = 5, name = (null)}
2020-08-16 13:38:09.628901+0800 OC-NSOperation[2556:109318] 1---<NSThread: 0x6000039dcd80>{number = 3, name = (null)}
2020-08-16 13:38:09.629143+0800 OC-NSOperation[2556:109318] 2---<NSThread: 0x6000039dcd80>{number = 3, name = (null)}

由打印结果可知：优先级高的限制性，再执行优先级低的，再执行依赖关系的

NSOperation、NSOperationQueue 线程间的通信

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

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

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

    // 2.添加操作
    [queue addOperationWithBlock:^{
        // 异步进行耗时操作
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程

        // 回到主线程
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            // 进行一些 UI 刷新等操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }];
    }];
}
   }];
}
***********打印结果********
2020-08-16 13:43:39.078799+0800 OC-NSOperation[2631:113017] 1---<NSThread: 0x60000328d940>{number = 3, name = (null)}
2020-08-16 13:43:39.097297+0800 OC-NSOperation[2631:112960] 2---<NSThread: 0x6000032c8e80>{number = 1, name = main}

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

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

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

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

1.例子:下面，我们模拟火车票售卖的方式，实现 NSOperation 线程安全和解决线程同步问题。
场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。

1）先来看看不考虑线程安全的代码：

/**
* 非线程安全：不使用 NSLock
* 初始化火车票数量、卖票窗口(非线程安全)、并开始卖票
*/
- (void)demo8{
    NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
    
    //总票数
    self.ticketSurplusCount = 10;

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

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

    // 3.创建卖票操作 op1
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
       [self saleTicketNotSafe];
    }];

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

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

/**
 * 售卖火车票(非线程安全)
 */
- (void)saleTicketNotSafe {
    while (1) {
        if (self.ticketSurplusCount > 0) {
            //如果还有票，继续售卖
            self.ticketSurplusCount--;
            NSLog(@"%@", [NSString stringWithFormat:@"剩余票数:%ld 窗口:%@", (long)self.ticketSurplusCount, [NSThread currentThread]]);
            [NSThread sleepForTimeInterval:0.2];
        } else {
            NSLog(@"所有火车票均已售完");
            break;
        }
    }
}

打印结果：

2020-08-16 13:51:15.967134+0800 OC-NSOperation[2709:117554] currentThread---<NSThread: 0x600000170d40>{number = 1, name = main}
2020-08-16 13:51:15.970381+0800 OC-NSOperation[2709:117657] 剩余票数:9 窗口:<NSThread: 0x60000013c980>{number = 6, name = (null)}
2020-08-16 13:51:15.971286+0800 OC-NSOperation[2709:117652] 剩余票数:8 窗口:<NSThread: 0x600000170ac0>{number = 7, name = (null)}
2020-08-16 13:51:16.171627+0800 OC-NSOperation[2709:117657] 剩余票数:7 窗口:<NSThread: 0x60000013c980>{number = 6, name = (null)}
2020-08-16 13:51:16.171722+0800 OC-NSOperation[2709:117652] 剩余票数:6 窗口:<NSThread: 0x600000170ac0>{number = 7, name = (null)}
2020-08-16 13:51:16.374218+0800 OC-NSOperation[2709:117657] 剩余票数:5 窗口:<NSThread: 0x60000013c980>{number = 6, name = (null)}
2020-08-16 13:51:16.374490+0800 OC-NSOperation[2709:117652] 剩余票数:4 窗口:<NSThread: 0x600000170ac0>{number = 7, name = (null)}
2020-08-16 13:51:16.574756+0800 OC-NSOperation[2709:117657] 剩余票数:3 窗口:<NSThread: 0x60000013c980>{number = 6, name = (null)}
2020-08-16 13:51:16.574900+0800 OC-NSOperation[2709:117652] 剩余票数:2 窗口:<NSThread: 0x600000170ac0>{number = 7, name = (null)}
2020-08-16 13:51:16.778734+0800 OC-NSOperation[2709:117652] 剩余票数:1 窗口:<NSThread: 0x600000170ac0>{number = 7, name = (null)}
2020-08-16 13:51:16.778655+0800 OC-NSOperation[2709:117657] 剩余票数:1 窗口:<NSThread: 0x60000013c980>{number = 6, name = (null)}
2020-08-16 13:51:16.980112+0800 OC-NSOperation[2709:117657] 剩余票数:0 窗口:<NSThread: 0x60000013c980>{number = 6, name = (null)}
2020-08-16 13:51:16.980114+0800 OC-NSOperation[2709:117652] 剩余票数:0 窗口:<NSThread: 0x600000170ac0>{number = 7, name = (null)}
2020-08-16 13:51:17.183727+0800 OC-NSOperation[2709:117657] 所有火车票均已售完
2020-08-16 13:51:17.183727+0800 OC-NSOperation[2709:117652] 所有火车票均已售完

可以看到：在不考虑线程安全，不使用 NSLock 情况下，得到票数是错乱的，这样显然不符合我们的需求，所以我们需要考虑线程安全问题。

2）再来看看考虑线程安全的代码:
线程安全解决方案：可以给线程加锁，在一个线程执行该操作的时候，不允许其他线程进行操作。iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/get等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。

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

- (void)demo9 {
    NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
    
    // 总票数
    self.ticketSurplusCount = 10;

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

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

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

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

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

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

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

        // 加锁
        [self.lock lock];

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

        // 解锁
        [self.lock unlock];

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

 