苹果工程师对iOS线程开发的那点事津津乐道

Posted 2022-02-07 一眼万年的星空

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了苹果工程师对iOS线程开发的那点事津津乐道相关的知识，希望对你有一定的参考价值。

pthread,Thread总结

pthread: 通用的多线程API

使用方法

// 1. 创建线程: 定义一个pthread_t类型变量
pthread_t thread;
// 2. 开启线程: 执行任务
pthread_create(&thread, NULL, run, NULL);
// 3. 设置子线程的状态设置为 detached，该线程运行结束后会自动释放所有资源
pthread_detach(thread);
void * run(void *param)    // 新线程调用方法，里边为需要执行的任务

    NSLog(@"%@", [NSThread currentThread]);
    return NULL;

pthread_create(&thread, NULL, run, NULL); 中各项参数含义：

- 第一个参数&thread是线程对象，指向线程标识符的指针
- 第二个是线程属性，可赋值NULL

- 第三个run表示指向函数的指针(run对应函数里是需要在新线程中执行的任务)
- 第四个是运行函数的参数，可赋值NULL

其他方法

pthread_create() 创建一个线程
pthread_exit() 终止当前线程

pthread_cancel() 中断另外一个线程的运行
pthread_join() 阻塞当前的线程，直到另外一个线程运行结束

pthread_attr_init() 初始化线程的属性
pthread_attr_setdetachstate() 设置脱离状态的属性（决定这个线程在终止时是否可以被结合）

pthread_attr_getdetachstate() 获取脱离状态的属性
pthread_attr_destroy() 删除线程的属性

pthread_kill() 向线程发送一个信号

Thread：苹果官方提供，更加面向对象，但需要程序员自己管理线程的生命周期

使用方法

创建，启动线程

先创建线程，再启动线程

// 1. 创建线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
// 2. 启动线程
[thread start];    // 线程一启动，就会在线程thread中执行self的run方法
// 新线程调用方法，里边为需要执行的任务
- (void)run 
     NSLog(@"%@", [NSThread currentThread]);

创建线程后自动启动线程

// 1. 创建线程后自动启动线程
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
// 新线程调用方法，里边为需要执行的任务
- (void)run 
     NSLog(@"%@", [NSThread currentThread]);

隐式创建并启动线程

// 1. 隐式创建并启动线程
[self performSelectorInBackground:@selector(run) withObject:nil];
// 新线程调用方法，里边为需要执行的任务
- (void)run 
     NSLog(@"%@", [NSThread currentThread]);

线程相关方法

// 获得主线程

(NSThread *)mainThread;
// 判断是否为主线程(对象方法)
(BOOL)isMainThread;
// 判断是否为主线程(类方法)
(BOOL)isMainThread;
// 获得当前线程
NSThread *current = [NSThread currentThread];
// 线程的名字——setter方法
(void)setName:(NSString *)n;
// 线程的名字——getter方法
(NSString *)name;

线程状态控制方法

启动线程方法

- (void)start;
// 线程进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态

阻塞（暂停）线程方法

+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 线程进入阻塞状态

强制停止线程

+ (void)exit;
// 线程进入死亡状态

线程间通信

/**
 * 创建一个线程下载图片
 */
- (void)downloadImageOnSubThread 
    // 在创建的子线程中调用downloadImage下载图片
    [NSThread detachNewThreadSelector:@selector(downloadImage) toTarget:self withObject:nil];


/**
 * 下载图片，下载完之后回到主线程进行 UI 刷新
 */
- (void)downloadImage 
    NSLog(@"current thread -- %@", [NSThread currentThread]);
    
    // 1. 获取图片 imageUrl
    NSURL *imageUrl = [NSURL URLWithString:@"https://ysc-demo-1254961422.file.myqcloud.com/YSC-phread-NSThread-demo-icon.jpg"];
    
    // 2. 从 imageUrl 中读取数据(下载图片) -- 耗时操作
    NSData *imageData = [NSData dataWithContentsOfURL:imageUrl];
    // 通过二进制 data 创建 image
    UIImage *image = [UIImage imageWithData:imageData];
    
    // 3. 回到主线程进行图片赋值和界面刷新
    [self performSelectorOnMainThread:@selector(refreshOnMainThread:) withObject:image waitUntilDone:YES];


/**
 * 回到主线程进行图片赋值和界面刷新
 */
- (void)refreshOnMainThread:(UIImage *)image 
    NSLog(@"current thread -- %@", [NSThread currentThread]);
    
    // 赋值图片到imageview
    self.imageView.image = image;

线程安全和线程同步

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

//利用互斥锁解决多个线程同步问题

线程间状态转换

GCD总结

核心概念：任务&队列

任务：

同步执行（sync） ：

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

异步执行（async） ：

- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。

队列：

任务的等待队列，先进先出原则

串行队列（Serial Dispatch Queue） ：

- 每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）

并发队列（Concurrent Dispatch Queue） ：

- 可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）

并发队列 的并发功能只有在异步（dispatch_async）函数下才有效

使用GCD

创建一个队列（串行或并发）
将任务放到等待队列中，系统就会根据任务类型执行任务（同步或异步）

创建串行或并发队列

let serialQueue = DispatchQueue(label: "SCGCD", attributes: .init(rawValue: 0))
let conQueue = DispatchQueue(label: "Mazy", attributes: .concurrent)

对于串行队列，GCD提供主队列

对于并发队列，GCD默认提供全局并发队列

创建任务

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

同步执行 + 主队列

特点(主线程调用)：互等卡主不执行。
特点(其他线程调用)：不会开启新线程，执行完一个任务，再执行下一个任务。

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]);      // 打印当前线程
        );
    );

GCD其他方法

GCD栅栏方法：dispatch_barrier_async

GCD延时方法：dispatch_after

GCD信号量-dispatch_semaphore

在 Dispatch Semaphore 中，使用计数,计数为0时等待，不可通过。计数为1或大于1时，计数减1且不等待，可通过。

dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量
dispatch_semaphore_signal：发送一个信号，让信号总量加1

dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。

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

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

保持线程同步，将异步执行任务转换为同步执行任务
保证线程安全，为线程加锁(访问独享性资源）

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

Operation, OperationQueue 总结（对GCD封装，完全面向对象）

核心概念：操作与操作队列

操作（Operation）：

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

操作队列（Operation Queues）：

- 这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
- 操作队列通过设置 最大并发操作数 （maxConcurrentOperationCount） 来控制并发、串行。

- NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

使用步骤

Operation一般配合OperationQueue使用，默认情况下，Operation单独使用系统同步执行操作，配合使用实现异步执行操作

NSOperation 实现多线程的使用步骤分为三步：

创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
创建队列：创建 NSOperationQueue 对象。

将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

之后，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。

创建Operation

BlockOperaion

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

- (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]); // 打印当前线程
        
    ];
    

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

创建OperationQueue

主队列

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

// 主队列获取方法
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]

- (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]); // 打印当前线程
        
    ];

OperationQueue控制串行，并发执行

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

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

最大并发操作数：maxConcurrentOperationCount

- maxConcurrentOperationCount 默认情况下为-1，表示不进行限制，可进行并发执行。
- maxConcurrentOperationCount 为1时，队列为串行队列。只能串行执行。

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

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

Operation操作依赖，控制操作执行的先后顺序

(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。
(void)removeDependency:(NSOperation *)op; 移除依赖，取消当前操作对操作 op 的依赖。

@property (readonly, copy) NSArray<NSOperation > dependencies; 在当前操作开始执行之前完成执行的所有操作对象数组。

Operation优先级

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

（优先级不能取代依赖关系,如果要控制操作间的启动顺序，则必须使用依赖关系。）

就绪状态下的操作：

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

Operation，OperationQueue 线程间通信

/**
 * 线程间通信
 */
- (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]); // 打印当前线程
            
        ];
    ];

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

多线程同步安全问题（线程加锁避免同时访问独享型资源）

iOS 实现线程加锁有很多种方式。@synchronized、 NSLock、NSRecursiveLock、NSCondition、NSConditionLock、pthread_mutex、dispatch_semaphore、OSSpinLock、atomic(property) set/ge等等各种方式。这里我们使用 NSLock 对象来解决线程同步问题。NSLock 对象可以通过进入锁时调用 lock 方法，解锁时调用 unlock 方法来保证线程安全。

/**
 * 售卖火车票(线程安全)
 */
- (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;

常用属性方法

NSOperation 常用属性和方法

取消操作方法

(void)cancel; 可取消操作，实质是标记 isCancelled 状态。
判断操作状态方法
(BOOL)isFinished; 判断操作是否已经结束。

(BOOL)isCancelled; 判断操作是否已经标记为取消。
(BOOL)isExecuting; 判断操作是否正在在运行。

(BOOL)isReady; 判断操作是否处于准备就绪状态，这个值和操作的依赖关系相关。
操作同步
(void)waitUntilFinished; 阻塞当前线程，直到该操作结束。可用于线程执行顺序的同步。

(void)setCompletionBlock:(void (^)(void))block; completionBlock 会在当前操作执行完毕时执行 completionBlock。
(void)addDependency:(NSOperation *)op; 添加依赖，使当前操作依赖于操作 op 的完成。

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

NSOperationQueue 常用属性和方法

取消/暂停/恢复操作

(void)cancelAllOperations; 可以取消队列的所有操作。
(BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。

(void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。
操作同步
(void)waitUntilAllOperationsAreFinished; 阻塞当前线程，直到队列中的操作全部执行完毕。
添加/获取操作

(void)addOperationWithBlock:(void (^)(void))block; 向队列中添加一个 NSBlockOperation 类型操作对象。
(void)addOperations:(NSArray *)ops waitUntilFinished:(BOOL)wait; 向队列中添加操作数组，wait 标志是否阻塞当前线程直到所有操作结束

(NSArray *)operations; 当前在队列中的操作数组（某个操作执行结束后会自动从这个数组清除）。
(NSUInteger)operationCount; 当前队列中的操作数。
获取队列

(id)currentQueue; 获取当前队列，如果当前线程不是在 NSOperationQueue 上运行则返回 nil。
(id)mainQueue; 获取主队列。

注意：
这里的暂停和取消（包括操作的取消和队列的取消）并不代表可以将当前的操作立即取消，而是当当前的操作执行完毕之后不再执行新的操作。
暂停和取消的区别就在于：暂停操作之后还可以恢复操作，继续向下执行；而取消操作之后，所有的操作就清空了，无法再接着执行剩下的操作。

RunLoop总结

简介

RunLoop 实际上是一个对象，这个对象在循环中用来处理程序运行过程中出现的各种事件（比如说触摸事件、UI刷新事件、定时器事件、Selector事件），从而保持程序的持续运行。
RunLoop 在没有事件处理的时候，会使线程进入睡眠模式，从而节省 CPU 资源，提高程序性能。

和线程关系

RunLoop 和线程是息息相关的，我们知道线程的作用是用来执行特定的一个或多个任务，在默认情况下，线程执行完之后就会退出，就不能再执行任务了。这时我们就需要采用一种方式来让线程能够不断地处理任务，并不退出。所以，我们就有了 RunLoop。

一条线程对应一个RunLoop对象，每条线程都有唯一一个与之对应的 RunLoop 对象。
RunLoop 并不保证线程安全。我们只能在当前线程内部操作当前线程的 RunLoop 对象，而不能在当前线程内部去操作其他线程的 RunLoop 对象方法。

RunLoop 对象在第一次获取 RunLoop 时创建，销毁则是在线程结束的时候。
主线程的 RunLoop 对象系统自动帮助我们创建好了（原理如 1.3 所示），而子线程的 RunLoop对象需要我们主动创建和维护。

从上边可看出，程序一直在 do-while 循环中执行，所以 UIApplicationMain 函数一直没有返回，我们在运行程序之后程序不会马上退出，会保持持续运行状态。

下图是苹果官方给出的 RunLoop 模型图。

从上图中可以看出，RunLoop 就是线程中的一个循环，RunLoop 会在循环中会不断检测，通过 Input sources（输入源）和 Timer sources（定时源）两种来源等待接受事件；然后对接受到的事件通知线程进行处理，并在没有事件的时候让线程进行休息。

RunLoop相关类

CFRunLoopRef：代表 RunLoop 的对象
CFRunLoopModeRef：代表 RunLoop 的运行模式

CFRunLoopSourceRef：就是 RunLoop 模型图中提到的输入源 / 事件源
CFRunLoopTimerRef：就是 RunLoop 模型图中提到的定时源

CFRunLoopObserverRef：观察者，能够监听 RunLoop 的状态改变

接着来讲解这 5 个类的相互关系：

一个RunLoop对象（CFRunLoopRef）中包含若干个运行模式（CFRunLoopModeRef）。而每一个运行模式下又包含若干个输入源（CFRunLoopSourceRef）、定时源（CFRunLoopTimerRef）、观察者（CFRunLoopObserverRef）。

每次 RunLoop 启动时，只能指定其中一个运行模式（CFRunLoopModeRef），这个运行模式（CFRunLoopModeRef）被称作当前运行模式（CurrentMode）。
如果需要切换运行模式（CFRunLoopModeRef），只能退出当前 Loop，再重新指定一个运行模式（CFRunLoopModeRef）进入。

这样做主要是为了分隔开不同组的输入源（CFRunLoopSourceRef）、定时源（CFRunLoopTimerRef）、观察者（CFRunLoopObserverRef），让其互不影响。

CFRunLoop

Core Foundation

CFRunLoopGetCurrent(); // 获得当前线程的 RunLoop 对象
CFRunLoopGetMain(); // 获得主线程的 RunLoop 对象

CFRunLoopMode

系统默认定义了多种运行模式（CFRunLoopMode），如下：

kCFRunLoopDefaultMode：App的默认运行模式，通常主线程是在这个运行模式下运行
UITrackingRunLoopMode：跟踪用户交互事件（用于 ScrollView 追踪触摸滑动，保证界面滑动时不受其他Mode影响）

UIInitializationRunLoopMode：在刚启动App时第进入的第一个 Mode，启动完成后就不再使用
GSEventReceiveRunLoopMode：接受系统内部事件，通常用不到

kCFRunLoopCommonModes：伪模式，不是一种真正的运行模式（后边会用到）

其中kCFRunLoopDefaultMode、UITrackingRunLoopMode、kCFRunLoopCommonModes是我们开发中需要用到的模式

CFRunLoopTimer

伪模式（kCFRunLoopCommonModes） ，这其实不是一种真实的模式，而是一种标记模式，意思就是可以在打上Common Modes标记的模式下运行。

那么哪些模式被标记上了Common Modes呢？

NSDefaultRunLoopMode 和 UITrackingRunLoopMode。

所以我们只要我们将NSTimer添加到当前RunLoop的kCFRunLoopCommonModes（Foundation框架下为NSRunLoopCommonModes）下，我们就可以让NSTimer在不做操作和拖动Text View两种情况下愉快的正常工作了。

具体做法就是讲添加语句改为[[NSRunLoop currentRunLoop] addTimer:timer forMode:NSRunLoopCommonModes];

CFRunLoopSource(输入源，事件源）

CFRunLoopSourceRef有两种分类方法。

第一种按照官方文档来分类（就像RunLoop模型图中那样）：

- Port-Based Sources（基于端口）
- Custom Input Sources（自定义）

- Cocoa Perform Selector Sources

第二种按照函数调用栈来分类：

- Source0 ：非基于Port
- Source1：基于Port，通过内核和其他线程通信，接收、分发系统事件

这两种分类方式其实没有区别，只不过第一种是通过官方理论来分类，第二种是在实际应用中通过调用函数来分类。

CFRunLoopObserver

CFRunLoopObserverRef是观察者，用来监听RunLoop的状态改变

CFRunLoopObserverRef可以监听的状态改变有以下几种：

typedef CF_OPTIONS(CFOptionFlags, CFRunLoopActivity) 
    kCFRunLoopEntry = (1UL << 0),               // 即将进入Loop：1
    kCFRunLoopBeforeTimers = (1UL << 1),        // 即将处理Timer：2    
    kCFRunLoopBeforeSources = (1UL << 2),       // 即将处理Source：4
    kCFRunLoopBeforeWaiting = (1UL << 5),       // 即将进入休眠：32
    kCFRunLoopAfterWaiting = (1UL << 6),        // 即将从休眠中唤醒：64
    kCFRunLoopExit = (1UL << 7),                // 即将从Loop中退出：128
    kCFRunLoopAllActivities = 0x0FFFFFFFU       // 监听全部状态改变  
;

- (void)viewDidLoad 
    [super viewDidLoad];

    // 创建观察者
    CFRunLoopObserverRef observer = CFRunLoopObserverCreateWithHandler(CFAllocatorGetDefault(), kCFRunLoopAllActivities, YES, 0, ^(CFRunLoopObserverRef observer, CFRunLoopActivity activity) 
        NSLog(@"监听到RunLoop发生改变---%zd",activity);
    );

    // 添加观察者到当前RunLoop中
    CFRunLoopAddObserver(CFRunLoopGetCurrent(), observer, kCFRunLoopDefaultMode);

    // 释放observer，最后添加完需要释放掉
    CFRelease(observer);

RunLoop原理

RunLoop运行逻辑

在每次运行开启RunLoop的时候，所在线程的RunLoop会自动处理之前未处理的事件，并且通知相关的观察者。

具体的顺序如下：

通知观察者RunLoop已经启动
通知观察者即将要开始的定时器

通知观察者任何即将启动的非基于端口的源
启动任何准备好的非基于端口的源

如果基于端口的源准备好并处于等待状态，立即启动；并进入步骤9
通知观察者线程进入休眠状态

将线程置于休眠知道任一下面的事件发生：

- 某一事件到达基于端口的源
- 定时器启动

- RunLoop设置的时间已经超时
- RunLoop被显示唤醒

通知观察者线程将被唤醒
处理未处理的事件

- 如果用户定义的定时器启动，处理定时器事件并重启RunLoop。进入步骤2
- 如果输入源启动，传递相应的消息

- 如果RunLoop被显示唤醒而且时间还没超时，重启RunLoop。进入步骤2

通知观察者RunLoop结束。

实战运用

Timer使用

UIImageView推迟显示

有两种方法：

1. 监听UIScrollView的滚动

因为UITableView继承自UIScrollView，所以我们可以通过监听UIScrollView的滚动，实现UIScrollView相关delegate即可。

2. 利用PerformSelector设置当前线程的RunLoop的运行模式

利用performSelector方法为UIImageView调用setImage:方法，并利用inModes将其设置为RunLoop下NSDefaultRunLoopMode运行模式。代码如下：

[self.imageView performSelector:@selector(setImage:) withObject:[UIImage imageNamed:@"tupian"] afterDelay:4.0 inModes:NSDefaultRunLoopMode];

青山不改，绿水长流，后会有期！！！

以上是关于苹果工程师对iOS线程开发的那点事津津乐道的主要内容，如果未能解决你的问题，请参考以下文章

synchronized 与 Lock 的那点事

python爬虫常见的那点问题！

PCB CAM 钻孔补偿那点事

UIScrollview 与 Autolayout 的那点事

关于软件测试工作的那点事

Android Framework:关于AMS的那点事

苹果工程师对iOS线程开发的那点事津津乐道

pthread,Thread总结

pthread: 通用的多线程API

其他方法

Thread：苹果官方提供，更加面向对象，但需要程序员自己管理线程的生命周期

使用方法

创建，启动线程

线程相关方法

线程状态控制方法

线程间通信

线程安全和线程同步

线程间状态转换

GCD总结

核心概念：任务&队列

使用GCD

创建串行或并发队列

创建任务

GCD线程通信

GCD其他方法

GCD信号量-dispatch_semaphore

Operation, OperationQueue 总结 （对GCD封装，完全面向对象）

核心概念：操作与操作队列

使用步骤

创建Operation

BlockOperaion

创建OperationQueue

将操作放到队列中 (并发执行）

OperationQueue控制串行，并发执行

Operation操作依赖，控制操作执行的先后顺序

Operation优先级

Operation，OperationQueue 线程间通信

多线程同步安全问题（线程加锁避免同时访问独享型资源）

常用属性方法

NSOperation 常用属性和方法

NSOperationQueue 常用属性和方法

RunLoop总结

简介

和线程关系

RunLoop相关类

CFRunLoop

CFRunLoopMode

CFRunLoopTimer

CFRunLoopSource(输入源，事件源）

CFRunLoopObserver

RunLoop原理

RunLoop运行逻辑

实战运用

Timer使用

UIImageView推迟显示

1. 监听UIScrollView的滚动

2. 利用PerformSelector设置当前线程的RunLoop的运行模式

青山不改，绿水长流，后会有期！！！

Operation, OperationQueue 总结（对GCD封装，完全面向对象）