苹果工程师对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 实现多线程的使用步骤分为三步：

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

1. 将操作加入到队列中：将 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];

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

1. - (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]
}

1. - (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。

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

1. RunLoop 对象在第一次获取 RunLoop 时创建，销毁则是在线程结束的时候。
2. 主线程的 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），如下：

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

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

1. 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会自动处理之前未处理的事件，并且通知相关的观察者。

具体的顺序如下：

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

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

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

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

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

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

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

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

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

1. 通知观察者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];

问答题。

1.GCD执行原理？

GCD底层有一个线程池，这个线程池存放的是一个个的线程，这个线程池中的线程可以重用，当一段时间这个线程没有被调用就会被销毁，️ 开辟多少线程不是由同步异步决定的而是底层线程池决定的，线程池是系统维护，

四 使用（简单介绍几种）

1.延迟

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{

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

  });

2.单例

 static dispatch_once_t onceToken;

   dispatch_once(&onceToken, ^{   

  });

1. 栅栏（可以让A异步执行完毕执行B异步）

dispatch_barrier_async(queue, ^{

        // 追加任务 barrier

        for (int i = 0; i < 2; ++i) {

            [NSThread sleepForTimeInterval:2];              // 模拟耗时操作

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

        }

    });

4.信号量

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

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

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