线程的串行

• 一个线程中任务的执行是串行的
  • 如果要再一个线程中执行多个任务，那么只能一个一个的按顺序执行这些任务
  • 也就是说同一时间内，一个线程只能执行一个任务

多线程

• 一个进程中，可以开启多条线程，每条线程可以并行(同时)执行不同的任务

多线程的优缺点

• 优点：

  • 能适当提高程序的执行效率
  • 能适当提高资源利用率(CPU、内存利用率)

• 缺点：

  • 创建线程是有开销的，iOS下主要成本：内核数据结构(大于1KB)、栈空间(子线程512KB、主线程1MB)，创建线程大于需要90毫秒的创建时间
  • 如果开启大量线程，会降低程序的性能
  • 线程越多，CPU在调度线程上的开销就越大
  • 程序设计更加复杂：比如线程之间的通信、多线程的数据共享

iOS中多线程的实现方案

• pthread:

  • 一套C语言的通用的多线程API
  • 跨平台，使用难度大
  • 程序员管理线程的生命周期，在iOS开发中几乎不用

• NSThread：

  • 一套OC的多线程API
  • 使用更加面向对象，简单，更容易操作线程对象
  • 程序员管理生命周期，在iOS开发中偶尔使用

• GCD：

  • 一套C语言的多线程API
  • 旨在替代NSThread等线程技术，充分利用设备的多核
  • 系统自动管理生命周期，在iOS开发中经常使用

• NSOperation：

  • 一套OC的对象称API
  • 基于GCD（底层是GCD）
  • 比GCD多了一些简单实用的功能
  • 系统自动管理生命周期，在iOS开发中经常使用

pthread（了解）

// 创建pthread
pthread_t thread;
pthread_create(&thread, NULL, method, NULL);

void * method(void *param){
    // 执行耗时操作
    return NULL;
}

NSThread

// 创建线程
// 使用NSThread创建的线程去执行耗时操作，当耗时操作执行完，线程会自动回收
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
// 启动线程
[thread start];

// 获得主线程
[NSThread mainThread];

// 是否是主线程
[thread isMainThread];
[NSThread isMainThread];

// 获得当前线程
[NSThread currentThread];

// 设置创建的线程的名字
[thread setName:@"11"];

// 其他创建线程的方式

// 创建线程后自动启动线程
[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];

// 隐式创建并启动线程
[self performSelectorInBackground:@selector(run) withObject:nil];

• 线程的状态

  • 新建(New)：调用start方法启动，进入就绪（Runnable）状态
  • CPU调度当前线程，进入运行(Running)状态
  • CPU调度其他线程，进入就绪（Runnable）状态
  • 调用sleep方法或者等待同步锁，进入阻塞（Blocked）状态
  • sleep时间到或者得到同步锁，进入就绪（Runnable）状态
  • 线程任务执行完毕、异常、强制退出，进入死亡(Dead)状态

• 控制线程状态

// 启动线程
// 进入就绪状态 -> 运行状态，当前任务执行完毕，自动进入死亡状态
[thread start];

// 阻塞(暂停)线程
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2]];
[NSThread sleepForTimeInterval:11];

// 强制停止线程
// 进入死亡状态，线程一旦死亡，就不能再次开始任务
[NSThread exit];

• 多线程的安全隐患
  • 多个线程可能访问同一块资源，这样很容易引起数据错乱和数据安全问题
  • 解决办法：互斥锁(@synchronized)
    • 锁定1份代码只用一把锁，用多了无效
    • 优点：能有效防止因多线程抢夺资源造成的数据安全问题
    • 缺点：需要消耗大量的CPU资源
    • 使用场景：多条线程抢夺同一块资源，比如：修改同一个数据、修改同一个文件等

- (void)run
{
    // 执行耗时操作
    @synchronized (self) {
        // 需要执行的代码
    }
}

• 线程间通讯
  • 一个线程传递数据给另一个线程
  • 一个线程执行完特定任务之后，转到另一个线程继续执行任务

// waitUntilDone：是否等待run方法执行完成之后才继续执行

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

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

GCD（掌握，开发中经常使用）

• 纯C语言，提供了很多非常强大的函数
• GCD的优势：
  • GCD是苹果公司为多核的并行运算提出的解决方案
  • GCD会自动利用更多的CPU内核
  • GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
  • 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

任务和队列(这两个是GCD的核心概念)

• 任务：执行什么操作
• 队列：用来存放任务

GCD使用的步骤

• 定制任务
• 将任务添加到队列中
  • GCD会自动将队列中的任务取出，放到对应的线程中执行
  • 任务的取出遵循队列的FIFO原则：先进先出，后进后出

GCD中用来执行任务的常用函数

• 同步执行任务：dispatch_sync
• 异步执行任务：dispatch_async
• 同步和异步的区别：
  • 同步：只能在当前线程中执行任务，不具备开启新线程的能力
  • 异步：可以在新的线程中执行任务，具备开启新线程的能力

// 用异步的方式执行任务
dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
// 用同步的方式执行任务
dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);

队列的类型

• 并发队列

  • 可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
  • 并发功能只有在异步函数(dispatch_async)下才有效

• 串行队列

  • 让任务一个接着而一个的去执行（一个任务执行完毕后，在执行下一个任务）

• 容易混淆的术语

  • 同步和异步主要影响：能不能开启新线程
    • 同步：只是在当前线程中执行任务，不具备开启新线程的能力
    • 异步：可以在新的线程中执行任务，具备开启新线程的能力
  • 并发和串行主要影响：任务的执行方式
    • 并发：允许多个任务并发执行
    • 串行：任务一个接着一个的执行

并发队列

• 使用dispatch_queue_create函数创建即可

// "com.eyee.queue" : 表示队列的名称
// DISPATCH_QUEUE_CONCURRENT : 表示队列的类型是并发队列
 dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_CONCURRENT);

• 获取全局的并发队列

// DISPATCH_QUEUE_PRIORITY_DEFAULT : 表示队列的优先级
// 第二个参数暂时无用，保留参数，传0即可
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

// 全局并发队列的优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2      // 高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0   // 中(默认)
#define DISPATCH_QUEUE_PRIORITY_LOW (-2)    // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

串行队列

• 使用dispatch_queue_create函数创建

// "com.eyee.queue" : 表示队列的名称
// DISPATCH_QUEUE_SERIAL : 表示队列的类型是串行队列
dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_SERIAL);

• 使用主队列
  • 主队列是GCD自带的一种特殊的串行队列
  • 放在主队列中的任务，都会放到主线程中执行
  • 使用dispatch_get_main_queue()获得主队列

dispatch_queue_t queue = dispatch_get_main_queue();

各种情况介绍

• 异步函数 + 并发队列：可以同时开启多条线程，并发执行任务

dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
});
dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});

• 同步函数 + 并发队列：不会开启新的线程，在当前线程中串行执行任务

dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_CONCURRENT);

dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});

• 异步函数 + 串行队列：会开启新线程，但是任务是串行执行

dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
});
dispatch_async(queue, ^{
});
dispatch_async(queue, ^{
});

• 同步函数 + 串行队列：不会会开启新线程，任务是串行执行

dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});

• 异步函数 + 主队列：在主线程中串行执行任务

dispatch_queue_t queue = dispatch_get_main_queue();

dispatch_async(queue, ^{
});
dispatch_async(queue, ^{
});
dispatch_async(queue, ^{
});

• 同步函数 + 主队列

// 这种方式分两种情况：
// 如果当前线程是主线程，那么程序会卡死，任务也不会执行
// 如果当前线程不是主线程，那么会在主线程中串行执行任务
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});
dispatch_sync(queue, ^{
});

线程直接通信

• 最常用的就是在子线程中执行耗时操作，执行完毕之后回到主线程刷新UI

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
     // 执行耗时操作
       
    // 回到主线程
    dispatch_async(dispatch_get_main_queue(), ^{
        // 刷新UI
    });
});

其他常用方法

• 执行任务方法：dispatch_barrier_async
• 在前面的任务执行结束之后它才执行，而且它后面的任务需要等到它执行完毕之后才会执行
• 这个queue不能是全局并发队列

dispatch_queue_t queue = dispatch_queue_create("com.eyee.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
});
dispatch_async(queue, ^{
});

dispatch_barrier_async(queue, ^{
});

dispatch_async(queue, ^{
});

• 延时执行

[self performSelector:@selector(method) withObject:nil afterDelay:10];

[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(method) userInfo:nil repeats:NO];

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // 10秒以后要执行的代码
});

• 在程序生命周期内只执行一次

static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
    
});

• 快速迭代

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 第一个参数：循环多少次
// 第二个参数：执行任务的队列
// 第三个参数：每次循环当前的index，相当于for循环中的i
dispatch_apply(10, queue, ^(size_t index) {
    
});

• 队列组
  • 执行两个耗时操作
  • 等两个耗时操作执行完毕之后，在回到主线程执行操作

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, queue, ^{
   // 第一个耗时操作
});
dispatch_group_async(group, queue, ^{
   // 第二个耗时操作
});
dispatch_group_notify(group, queue, ^{
    // 1、执行操作
    // 2、回到主线程
    dispatch_async(dispatch_get_main_queue(), ^{
        
    });
});

NSOperation

• NSOperation是一个抽象类，并不具备封装操作的能力，必须使用它的子类：

  • NSInvocationOperation
  • NSBlockOperation
  • 自定义子类继承NSOperation，实现内部相应的方法

• NSOperation和NSOperationQueue配合也能实现多线程变成

• 实现步骤：

  • 将需要执行的操作封装到一个NSOperation对象中
  • 然后将NSOperation对象添加到一个NSOperationQueue钟
  • 系统会自动将NSOperationQueue中的NSOperation取出来
  • 将取出的NSOperation封装的操作放到一条新线程中执行

基本使用

• 使用NSBlockOperation注意点：
  • 如果封装的操作数是1个，那么就会在当前线程中执行
  • 如果封装的操作数大于1个，那么会不会开启新的线程就要看系统的分配了(有的地方说会开启新的线程，但是我测试发现有时候开启，有时候不开启)

// 一般情况下，调用start方法后并不会开启新的线程
// 会在当前线程中执行操作
// 只有NSOperation放到NSOperationQueue中，才会开启线程
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(run) object:nil];
[op start];

// 创建NSBlockOperation对象
NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
    
}];
// 通过addExecutionBlock: 方法添加更多操作
[op addExecutionBlock:^{
    
}];
[op addExecutionBlock:^{
    
}];
[op start];

NSOperationQueue的作用

• NSOperation可以调用start方法来执行任务，但是默认是同步执行的
• 如果将NSOperation添加到NSOperationQueue中，系统自动异步执行NSOperation中的操作
• NSOperationQueue队列分两种：
  • 主队列：[NSOperationQueue mainQueue]
  • 其他队列：[[NSOperationQueue alloc] init]
    • 这个是并发也是串行，靠设置最大并发数决定

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

// 创建操作（任务）
// 创建NSInvocationOperation
NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(download1) object:nil];
// 添加任务到队列中
// 第一种方式：
[queue addOperation:op]; // [op start]
// 第二种方式：
[queue addOperationWithBlock:^{
    NSLog(@"download2 --- %@", [NSThread currentThread]);
}];

设置最大并发数

• 设置最大并发数之后，最多就开启这么多条线程，如果设置为1，那么就是串行队列
• 如果不设置，那么就让系统自动开启线程

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

挂起队列

• 有的时候需要暂停队列，有的时候需要恢复队列
• 满足这个条件的属性suspended
• 注意点：
  • 队列中可能加入很多个操作，也可以设置最大并发数
  • 如果队列中的某个操作已经开始执行，那么暂停队列，这个操作不会停下来
  • 如果某个操作没有开始执行，那么暂停队列，这个操作不会执行，当恢复队列之后继续执行

if (self.queue.isSuspended) {
    // 恢复队列，继续执行
    self.queue.suspended = NO;
} else {
    // 暂停（挂起）队列，暂停执行
    self.queue.suspended = YES;
}

取消操作

• 如果我们需要取消队列中的操作，需要用到的方法就是cancelAllOperations
• 注意点：
  • 取消之后不能恢复
  • 只能取消未开始的操作，已经开始的操作将继续执行
  • NSOperation中有cancel方法和cancelled属性，队列的cancelAllOperations方法也就是调用所有操作的cancel方法

// 这个方法是取消队列中的所有操作
// 注意：这里是取消未开始的的操作
[self.queue cancelAllOperations];

• 当我们自定义NSOperation的时候

  • 继承自NSOperation
  • 实现main方法，里面实现耗时操作
  • 在main方法中如果有好几个耗时操作，那么在每一个耗时操作开始之前，需要先判断当前任务是否取消
  • 自己创建自动释放池

  if (self.isCancelled) return;
  

操作依赖

• 比如一定要A操作执行完成之后才能执行B操作，那么可以使用依赖
• 注意点：一定不能相互依赖

// op3 依赖 op1 和 op2
// 也就是op1 和 op2 执行完成之后，op3才会执行
[op3 addDependency:op1];
[op3 addDependency:op2];

操作监听

• 监听一个操作执行完毕

NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{

}];
op.completionBlock = ^{
    // 操作执行完毕
};

线程间通信

• 基本上是回到主线程
• 在需要回到主线程的操作中，加入下面的代码：

// 回到主线程
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
}];