多线程

前言

今天我们主要看看关于线程与进程的一些面试相关的知识点,以及引发出来的多线程的相关知识点。

1. 线程、进程的概念

百度百科:

  • 线程(Thread)是操作系统能够进行运算调度的最小单位。它被包含在进程之中,是进程中的实际运作单位
  • 进程 (Process)是计算机中的程序关于某数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,是操作系统结构的基础

2. 线程、进程的关系

  1. 归属关系:一个进程必须至少有一条线程,因为进程的所有任务都在线程中执行;
  2. 地址空间:
    • 同一进程的线程共享本进程的地址空间,而进程之间则是独立的地址空间;
    • 线程没有地址空间,线程包含在进程地址空间中
  3. 资源分配:同一进程内的线程共享本进程内的资源(如内存、I/O、cpu等),但进程之间资源是相互独立的;
  4. 健壮性:进程崩溃后,保护模式下不会对其他进程产生影响,但一个线程崩溃会导致整个进程都死掉。所以多进程比多线程健壮
  5. 执行过程:每个独立的进程都有一个程序运行入口和顺序执行序列。但是线程不能独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制。
  6. 切换时,

3. 时间片 & 线程成本

3.1 时间片

CPU在多个任务之间进行快速切换,这个时间间隔就是时间片。

  1. 单核CPU
    • 同一时间,CPU只能处理1个线程。
  2. 多核CPU
    • 多线程同时执行 --> 需要多个CPU的处理器(多核)才可以做到。
    • 理论上,只要CPU在多个线程切换的足够快(时间片足够小),就可以做出同时执行的假象。
  3. 如果线程数非常多,CPU在多个线程之间切换,会消耗大量CPU资源,每个线程被调度的次数会降低,线程的执行效率会降低。
3.2 线程成本

根据官网描述,创建一个线程大概需要的成本

内核数据结构 1Kb
堆空间(iOS主线程:1MB,OSX主线程:8MB、其他辅助线程:512KB)
创建时间 90ms

4. 线程的生命周期

  1. 线程新建(new)出来之后,并不会立即执行,而是进入一个就绪(runnable)状态;
  2. 线程的运行(running)依赖CPU的调度,这时线程才开始执行任务;注意,如果当前的线程已经在运行(running)中,那么CPU会从可调度线程池中调用其它线程,去执行该任务。
  3. 运行中(running)的线程,被调用sleep或等待同步锁时,会进入阻塞(block)状态;当sleep结束或获取同步锁时,阻塞(block)状态就会解除,恢复就绪(runnable)状态
  4. 运行中(running)的线程,在任务执行完被强制退出时,线程自动进入Dead销毁

线程池调度

CPU从线程池中调度线程是按照下图的流程进行的


线程和RunLoop的关系

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

5. 多线程

以上大致讲解了线程和进程的概念以及它俩之间的关系,然后具体讲解了线程的生命周期和线程池的调度策略,此时我们明白了CPU在线程池中调度一个线程去执行任务的完整流程。当然,应用程序(例如App)本身的运行,肯定不止一个线程,而是多个线程串行或并发去执行多个任务,那么多线程执行任务又有什么意义呢?

5.1 多线程的意义

  • 优点
  1. 适当提高执行效率
  2. 适当提高资源的利用率(CPU、内存等)
  3. 线程上的任务执行完后,线程会自动销毁
  • 缺点
  1. 开启线程需要占用一定的内存空间(参照下面 第5点 线程成本 )
  2. 开启大量线程,会占用大量内存空间,降低程序性能
  3. 线程越多,CPU在调度线程上的开销越大
  4. 程序设计更加复杂(如线程间的通讯,多线程的数据共享等)

5.2 多线程技术方案

5.2.1 pthread

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

#import 

- (void)createThread {
    // 1. 创建线程:定义一个pthread_t类型变量
    pthread_t thread;
    // 2. 开启线程:执行任务
    //  参数1: 要开的线程变量
    //  参数2:线程的属性
    //  参数3:子线程的执行函数(任务)
    //  参数4:函数入参
    pthread_create(&thread, NULL, run, @"入参");
    // 3. 设置子线程的状态设置为detached,该线程运行结束后会自动释放所有资源
    pthread_detach(thread);
}

void * run(void * param) {
    NSLog(@"%@ %@", [NSThread currentThread], param);
    return NULL;
}

运行结果

pthread的相关api
  1. pthread_create(): 创建一个线程
  2. pthread_exit(): 终止当前线程
  3. pthread_cancel(): 中断另外一个线程的运行
  4. pthread_join():阻塞当前的线程,直到另外一个线程运行结束
  5. pthread_attr_init():初始化线程的属性
  6. pthread_attr_setdetachstate():设置脱离状态的属性(决定这个线程在终止时是否可以被结合)
  7. pthread_attr_getdetachstate():获取脱离状态的属性
  8. pthread_attr_destroy(): 删除线程的属性
  9. pthread_kill(): 向线程发送一个信号
5.2.2 NSThread

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

-(void)touchesBegan:(NSSet *)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:隐式创建线程并启动,快捷便利,不支持配置线程属性;

任务
run1无参数,run2带参数

NSThread相关api

请参考官方文档

经典的售票案例
@interface ViewController ()
@property (nonatomic, assign) NSInteger ticketSurplusCount; // 剩余票数
@property (nonatomic, strong) NSThread *ticketSaleWindow1; // 线程1 
@property (nonatomic, strong) NSThread *ticketSaleWindow2; // 线程2
@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];

    [self initTicketStatusSave];
}

/**
 * 初始化火车票数量、卖票窗口(线程安全)、并开始卖票
 */
- (void)initTicketStatusSave {
    // 1. 设置剩余火车票为 50
    self.ticketSurplusCount = 50;
    
    // 2. 设置北京火车票售卖窗口的线程
    self.ticketSaleWindow1 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicketSafe) object:nil];
    self.ticketSaleWindow1.name = @"北京火车票售票窗口";
    
    // 3. 设置上海火车票售卖窗口的线程
    self.ticketSaleWindow2 = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicketSafe) object:nil];
    self.ticketSaleWindow2.name = @"上海火车票售票窗口";
    
    // 4. 开始售卖火车票
    [self.ticketSaleWindow1 start];
    [self.ticketSaleWindow2 start];
}

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

以上示例是通过2个子线程出售火车票,其中通过@ synchronized互斥锁保证,每次只有一个线程去减少票的库存。

5.2.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 后面");
}
5.2.4 NSOperation

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

因为NSOperation是抽象基类,若要使用,要么直接继承NSOperation自定义子类,要么就使用它的两个派生子类:NSBlockOperationNSInvocationOperation,它们的区别在于:前者执行指定的方法,后者执行代码块,相对来说后者更加灵活易用。通常配合NSOperationQueue加入队列中执行任务。
示例

- (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);
}

7. 互斥锁 & 自旋锁

7.1 互斥锁

  1. 保证锁内代码,同一时间只有一条线程能够执行;
  2. 互斥锁的锁定范围应该尽量小,锁定范围越大,效率越差。
    参数:
  3. 能够加锁的任意NSObject对象。
  4. 锁对象要保证所有线程都能够访问。
  5. 如果代码只有一个地方需要加锁,大多都使用self,这样可以避免单独再创建一个锁对象。

7.2 自旋锁 OSSpinLock

自旋锁与互斥锁不一样,当一个线程获得锁之后,其他线程将会一直循环在那里查看是否该锁被释放。所以,此锁比较适用于锁的持有者保存时间较短的情况下。

优先级反转的问题

iOS 中,系统维护了 5 个不同的线程优先级/QoS: background,utility,default,user-initiated,user-interactive。高优先级线程始终会在低优先级线程前执行,一个线程不会受到比它更低优先级线程的干扰。这种线程调度算法会产生潜在的优先级反转问题,从而破坏了 spin lock。
具体来说,如果一个低优先级的线程获得锁并访问共享资源,这时一个高优先级的线程也尝试获得这个锁,它会处于 spin lock 的忙等状态从而占用大量 CPU。此时低优先级线程无法与高优先级线程争夺 CPU 时间,从而导致任务迟迟完不成、无法释放 lock。这并不只是理论上的问题,libobjc 已经遇到了很多次这个问题了,于是苹果的工程师停用了 OSSpinLock。

具体文章可以戳 不再安全的 OSSpinLock。

8. atomic & nonatomic

  • nonatomic非原子属性
  • atomic 原子属性(线程安全),针对多线程设计的,是默认值atomic能保证同一时间只有一个线程能够写入(但是同一个时间多个线程都可以取值),atomic本身就有一把锁(自旋锁)单写多读:单个线程写入,多个线程可以读取
  • atomic可保证线程安全,但需要消耗大量的资源;nonatomic是非线程安全,适合内存小的移动设备
iOS 开发的建议

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

你可能感兴趣的:(多线程)