本文的目的在于了解进程、线程、多线程、线程池等的基本概念及原理

1 线程 和 进程

1.1 线程 和 进程的定义

1.1.1 线程

• 线程是进程的基本执行单元，一个进程的所有任务都在线程中执行
• 进程要想执行任务，必须的有线程，进程至少要有一条线程
• 程序启动会默认开启一条线程，这条线程被称为 主线程 或者 UI线程

1.1.2 进程

• 进程是指在系统中正在运行的一个应用程序
• 每个进程之间是独立的，每个进程均运行在其专用的且受保护的内存空间内
• 通过“活动监视器”可以查看mac系统中所开启的线程

所以，可以简单的理解为：进程是线程的容器，而线程用来执行任务。在iOS中是单进程开发，一个进程就是一个app，进程之间是相互独立的，如支付宝、微信、qq等，这些都是属于不同的进程

1.2 线程 和 进程的关系

进程与线程之间的关系主要涉及两个方面：

1.2.1 地址空间

• 同一个进程的线程共享本进程的地址空间
• 进程之间则是独立的地址空间

1.2.2 资源拥有

• 同一个进程内线程共享本进程的资源，如内存、I/O、cpu等
• 进程之间资源是独立的

针对进程和线程，还有以下几点说明：

1. 进程崩溃后，保护模式下不会对其他进程产生影响，但一个线程崩溃会导致整个进程都死掉。所以多进程比多线程健壮。
2. 进程切换时，消耗的资源大。涉及频繁切换时，使用线程要好过于进程。同样要求同时进行且共享某些变量的并发操作时，只能用线程不能用进程。
3. 执行过程：每个独立的进程都有一个程序运行入口和顺序执行序列。但是线程不能独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
4. 线程是处理器调度的基本单位，但进程不是。
5. 线程没有地址空间，线程包含在进程地址空间中

1.3 线程 和 Runloop 的关系

1. runloop与线程是一一对应的，一个runloop对应一个核心的线程，为什么说是核心的，是因为runloop是可以嵌套的，但是核心的只能有一个，他们的关系保存在一个全局 的字典里。
2. runloop是来管理线程的，当线程的runloop被开启后，线程会在执行完任务后进入休 眠状态，有了任务就会被唤醒去执行任务
3. runloop在第一次获取时被创建，在线程结束时被销毁
4. 对于主线程来说，runloop在程序一启动就默认创建好了
5. 对于子线程来说，runloop是懒加载的，只有当我们使用的时候才会创建，所以在子线程用定时器要注意:确保子线程的runloop被创建，不然定时器不会回调。

2 多线程

2.1 多线程原理

• 对于单核CPU，同一时间，CPU只能处理一条线程，即只有一条线程在工作，
• iOS中的多线程同时执行的本质是 CPU在多个任务直接进行快速的切换，由于CPU调度线程的时间足够快，就造成了多线程的“同时”执行的效果。其中切换的时间间隔就是时间片

2.2 多线程的优缺点

2.2.1 优点

• 能适当提高程序的执行效率
• 能适当提高资源的利用率，如CPU、内存
• 线程上的任务执行完成后，线程会自动销毁

2.2.2 缺点

• 开启线程需要占用一定的内存空间，（参照下面 2.2.3 线程成本）
• 如果开启大量线程，会占用大量的内存空间，降低程序的性能
• 线程越多，CPU在调用线程上的开销就越大
• 程序设计更加复杂，比如线程间的通信，多线程的数据共享

2.2.3 线程成本

官方链接

翻译成中文

2.3 多线程技术方案

2.3.1 pthread

pthread是一套通用的多线程 API，可以在Unix/ Linux / Windows 等系统跨平台使用，使用 C 语言编写，需要程序员自己管理线程的生命周期，使用难度较大，我们在 iOS 开发中几乎不使用。

实例

#import <pthread.h>

- (void)createThread {
    // 1. 创建线程：定义一个pthread_t类型变量
    pthread_t threadId = NULL;
    //c字符串
    char *cString = "HelloCode";
//    NSString *ocString = @"Gavin";
    //延伸到: OC--C的混编 尤其在智能家居,SDK封装
    //抛出一个问题: 在ARC需要这样操作,在MRC不需要
    // OC prethread -- 跨平台
    // 锁
    int result = pthread_create(&threadId, NULL, pthreadTest, cString);
    if (result == 0) {
        NSLog(@"成功");
    } else {
        NSLog(@"失败");
    }
}

void *pthreadTest(void *param){
    // 接 C 语言的字符串
        NSLog(@"===> %@ %s", [NSThread currentThread], param);
    return NULL;
}

运行结果

截屏2020-12-31 下午3.00.12.png

相关API

2.3.2 NSThread

NSThread是苹果官方提供的，使用起来比pthread更加面向对象，简单易用，可直接操作线程对象，需要自己管理线程生命周期，实际开发中偶尔使用。

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    [self createThread1];
//    [self createThread2];
//    [self createThread3];
}

//MARK: - 创建线程
//创建线程 (手动启动)
-(void)createThread1{
    // 实例化一个线程对象
    NSThread *thread=[[NSThread alloc]initWithTarget:self selector:@selector(run1) object:nil];
    // 线程名称
    thread.name = @"Thread1Name";
    
    /**
     NSQualityOfServiceUserInteractive = 0x21, 用户交互         - 最高（21）
     NSQualityOfServiceUserInitiated = 0x19,   用户马上执行的事件 - 较高(19)
     NSQualityOfServiceUtility = 0x11,         普通任务         - 普通（11）
     NSQualityOfServiceBackground = 0x09,      后台任务         - 较低 (9)
     NSQualityOfServiceDefault = -1            常规            - 最低
     */
    
    // 线程优先级
    thread.qualityOfService = NSQualityOfServiceDefault;
    // 线程启动
    [thread start];
}

//创建线程 (自动启动)
-(void)createThread2{
    //创建线程后自动启动线程
    [NSThread detachNewThreadSelector:@selector(run2:) toTarget:self withObject:@"createThread2"];
}

//创建线程 (自动启动)
-(void)createThread3{
    //隐式创建线程并启动
    [self performSelectorInBackground:@selector(run2:) withObject:@"createThread3"];
}

//MARK: - 耗时操作
- (void)run1{
    for (int i=0; i<200; i++) {
        NSLog(@"%d----%@",i,[NSThread currentThread]);
    }
}

- (void)run2:(NSString*)param{
    for (int i=0; i<200; i++) {
        NSLog(@"%d----%@---%@",i,[NSThread currentThread],param);
    }
}

• 创建：

1. createThread1：手动启动线程，可以配置线程属性（名称、优先级）；
2. createThread2：自动启动线程，快捷便利，不支持配置线程属性;
3. createThread3：隐式创建线程并启动，快捷便利，不支持配置线程属性;

• 相关API

2.3.3 GCD

GCD(Grand Central Dispatch)，大中央调度。对线程操作进行了封装，加入了很多新的特性，内部进行了效率优化，提供了简洁的C语言接口，使用简单高效，是苹果推荐的方式。使用频率高。

#pragma mark - GCD演练
/**
 并发队列，同步执行
 */
- (void)gcdDemo4 {
    // 1. 队列
    dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);

    // 2. 同步执行任务
    for (int i = 0; i < 10; i++) {
        dispatch_sync(queue, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

/**
 并发队列，异步执行
 */
- (void)gcdDemo3 {
    // 1. 队列
    dispatch_queue_t queue = dispatch_queue_create("itcast", DISPATCH_QUEUE_CONCURRENT);

    // 2. 异步执行任务
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }

}

/**
 串行队列，异步执行
 */
- (void)gcdDemo2 {
    // 1. 队列
    dispatch_queue_t queue = dispatch_queue_create("itcast", NULL);

    // 2. 异步执行任务
    for (int i = 0; i < 10; i++) {
        dispatch_async(queue, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
}

/**
 串行队列，同步执行(开发中非常少用)
 */
- (void)gcdDemo1 {

    // 1. 队列
//    dispatch_queue_t queue = dispatch_queue_create("icast", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue = dispatch_queue_create("icast", NULL);
    NSLog(@"执行前----");

    // 执行任务
    for (int i = 0; i < 10; i++) {
        NSLog(@"调度----");

        // 在队列中"同步"执行任务，串行对列添加同步执行任务，会立即被执行
        dispatch_sync(queue, ^{
            NSLog(@"%@ %d", [NSThread currentThread], i);
        });
    }
    NSLog(@"for 后面");
}

2.3.4 NSOperation

NSOperation是基于GCD的一个抽象基类，将线程封装成要执行的操作，不需要管理线程的生命周期和同步，但比GCD可控性更强。例如可以加入操作依赖（addDependency）、设置操作队列最大可并发执行的操作个数（setMaxConcurrentOperationCount）、取消操作（cancel）等

NSOperation作为抽象基类不具备封装我们的操作的功能，需要使用两个它的实体子类：NSBlockOperation和NSInvocationOperation，或者继承NSOperation自定义子类

- (void)opDemo2 {
    NSOperationQueue *q = [[NSOperationQueue alloc] init];
    [q addOperationWithBlock:^{
        NSLog(@"耗时操作 %@", [NSThread currentThread]);

        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            NSLog(@"更新UI %@", [NSThread currentThread]);
        }];
    }];
}

- (void)opDemo1 {
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(downloadImage:) object:@"Invocation"];

    // start 会立即在当前线程执行 selector 方法
    //    [op start];

    // 将操作添加到队列，会自动异步执行
    NSOperationQueue *q = [[NSOperationQueue alloc] init];
    [q addOperation:op];
}

- (void)downloadImage:(id)obj {
    NSLog(@"%@ %@",  [NSThread currentThread], obj);
}

2.4 多线程声明周期

多线程的生命周期主要分为5部分：新建 - 就绪 - 运行 - 阻塞 - 死亡，如下图所示

part1: 新建

主要是实例化线程对象

part2: 就绪

线程对象调用start方法，将线程对象加入可调度线程池，等待CPU的调用，即调用start方法，并不会立即执行，进入就绪状态，需要等待一段时间，经CPU调度后才执行，也就是从就绪状态进入运行状态

part3: 运行

CPU负责调度可调度线程的执行，在线程执行完成之前，其状态可能会在就绪和运行之间来回切换，这个变化是由CPU负责，开发人员不能干预

part4: 阻塞

当满足某个预定条件时，可以使用休眠，即sleep，或者同步锁，阻塞线程执行。当进入sleep时，会重新将线程加入就绪中

part5: 死亡

运行中的任务，在任务执行完或被强制退出时（调用exit方法等退出），线程自动进入Dead销毁

线程的exit、cancel和suspend操作区别。

exit：一旦强行终止线程，后续的所有代码都不会被执行
cancel：并不会直接取消线程，只是给线程对象添加isCancelled标记
suspend：挂起状态，通过resume，可以恢复线程的任务执行

问题：线程的优先级越高，是不是意味着任务的执行越快？

并不是，线程执行的快慢，除了要看优先级，还需要查看资源的大小（即任务的复杂度）、以及 CPU 调度情况

2.5 线程池原理

step1: 判断线程池核心线程是否都在执行任务 ？

• NO，创建新的工作让线程去执行
• YES， 执行下一步

step2: 判断线程池工作队列是否饱满

• NO，将任务存储在工作队列
• YES，执行下一步

step3: 判断线程池中的线程都处于执行状态

• NO，安排线程去执行
• YES，饱和策略去处理

饱和策略：

2.5 线程安全

当多个线程同时访问一块资源时，容易引发数据错乱和数据安全问题，有以下两种解决方案：

• 互斥锁（即同步锁）：@synchronized
• 自旋锁

2.5.1 互斥锁

• 用于保护临界区，确保同一时间，只有一条线程能够执行
• 加了互斥锁的代码，当新线程访问时，如果发现其他线程正在执行锁定的代码，新线程就会进入休眠

针对互斥锁，还需要注意以下几点：

• 互斥锁的锁定范围，应该尽量小，锁定范围越大，效率越差
• 能够加锁的任意NSObject对象
• 锁对象要保证所有线程都能够访问
• 如果代码只有一个地方需要加锁，大多都使用self，这样可以避免单独再创建一个锁对象

2.5.2 自旋锁

• 自旋锁与互斥锁类似，但它不是通过休眠使线程阻塞，而是在获取锁之前一直处于忙等（即原地打转，称为自旋）阻塞状态
• 加入自旋锁，当新线程访问代码时，如果发现其他线程正在锁定代码，新线程会用死循环的方法，一直等待锁定的代码执行完成，即不停的尝试执行代码，比较消耗性能
• 使用场景：锁持有的时间短，且线程不希望在重新调度上花太多成本时，就需要使用自旋锁，属性修饰符atomic，本身就有一把自旋锁

问题： 互斥锁和自旋锁的区别?
解答：

• 同：在同一时间，保证了只有一条线程执行任务，即保证了相应同步的功能

• 不同：

  • 互斥锁：发现其他线程执行，当前线程 休眠（即就绪状态），进入等待执行，即挂起。一直等其他线程打开之后，然后唤醒执行

  • 自旋锁：发现其他线程执行，当前线程 一直询问（即一直访问），处于忙等状态，耗费的性能比较高

• 场景：根据任务复杂度区分，使用不同的锁，但判断不全时，更多是使用互斥锁去处理

  • 当前的任务状态比较短小精悍时，用自旋锁

  • 反之的，用互斥锁

2.5.3 atomic

• atomic是原子属性，是为多线程开发准备的，是默认属性！
• 在属性的 setter 方法中，增加了锁(自旋锁)，能够保证同一时间，单写多读：单个线程写入，多个线程可以读取。

2.5.4 nonatomic

• nonatomic 是非原子属性，非线程安全，性能高，适合内存小的移动设备

iOS官方建议：

所有属性都声明为nonatomic，避免多线程抢夺同一块资源，尽量将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力。