一、基本概念:(多线程是通过提高资源使用率来提高系统总体的效率)
- 进程:
可以理解成一个运行中的应用程序,是系统进行资源分配和调度的基本单位,是操作系统结构的基础,主要管理资源。 - 线程:
是进程的基本执行单元,一个进程对应多个线程。 - 主线程:
处理UI,所有更新UI的操作都必须在主线程上执行。不要把耗时操作放在主线程,界面会卡。 - 多线程:
在同一时刻,一个CPU只能处理1条线程,但CPU可以在多条线程之间快速的切换,只要切换的足够快,就造成了多线程一同执行的假象。 - 目的:
将耗时的操作放在后台执行
二、线程的状态与生命周期
线程的生命周期是:新建 - 就绪 - 运行 - 阻塞 - 死亡
-
线程状态示意图
图1
说明:
- 新建:
实例化线程对象 - 就绪:
向线程对象发送start消息,线程对象被加入可调度线程池等待CPU调度。 - 运行:
CPU 负责调度可调度线程池中线程的执行。线程执行完成之前,状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责,程序员不能干预。 - 阻塞:
当满足某个预定条件时,可以使用休眠或锁,阻塞线程执行。sleepForTimeInterval(休眠指定时长),sleepUntilDate(休眠到指定日期),@synchronized(self):(互斥锁)。 - 死亡:
正常死亡,线程执行完毕。非正常死亡,当满足某个条件后,在线程内部中止执行/在主线程中止线程对象 - [NSThread exit]:
一旦强行终止线程,后续的所有代码都不会被执行。 - [thread cancel]:
并不会直接取消线程,只是给线程对象添加 isCancelled 标记。
三、多线程的四种解决方案
- pthread
一套通用的多线程API
适用于 Unix / Linux / Windows 等系统
跨平台/可移植 - NSThread
使用更加面向对象
简单易用,可直接操作线程对象 - GCD
旨在替代 NSThread 等线程技术
充分利用设备的多核 - NSOperation
基于GCD(底层是GCD)
比GCD多了一些更简单实用的功能
使用更加面向对象
方案 | 语言 | 线程生命周期 | 实用频率 |
---|---|---|---|
pthread | C语言 | 程序员管理 | 几乎不用 |
NSThread | OC语言 | 程序员管理 | 偶尔使用 |
GCD | C语言 | 自动管理 | 经常使用 |
NSOperation | OC语言 | 自动管理 | 经常使用 |
四、线程安全问题
- 原因:
当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题。 - 解决多线程安全问题的方法:
方法一:互斥锁(同步锁)
@synchronized(锁对象) {
//需要锁定的代码
}
加了互斥做的代码,当新线程访问时,如果发现其他线程正在执行锁定的代码,新线程就会进入休眠。
注意:
判断的时候锁对象要存在,如果代码中只有一个地方需要加锁,大多都使用self作为锁对象,这样可以避免单独再创建一个锁对象。
锁对象切记不能是局部变量。
方法二:自选锁
加了自旋锁,当新线程访问代码时,如果发现有其他线程正在锁定代码,新线程会用死循环的方式,一直等待锁定的代码执行完成。相当于不停尝试执行代码,比较消耗性能。属性修饰nonatomic 和 atomic
nonatomic:非原子属性(非线程安全),同一时间可以有很多线程 读 和 写,效率高
atomic:原子属性(线程安全),保证同一时间只有一个线程能够写入(但是同一个时间多个线程都可以读值)
atomic:本身就有一把自旋锁,且只对 写 操作进行加锁,对 读 操作没有限制
五、NSThread的使用
- 三种创建方式:
- initWithTarget / initWithBlock
创建好后,需要通过 start 启动 - detachNewThreadSelector / detachNewThreadWithBlock
创建好之后自动启动 - performSelectorInBackground
创建好之后自动启动
//方法一
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(doSomething:) object:@"NSThread01"];
[thread start];
//方法二
[NSThread detachNewThreadSelector:@selector(doSomething:) toTarget:self withObject:@"NSThread02"];
//方法三
[self performSelectorInBackground:@selector(doSomething:) withObject:@"NSThread03"];
- (void)doSomething:(NSString *) object_str
{
NSLog(@"参数:%@, 线程:%@", object_str, [NSThread currentThread]);
}
- NSThread相关类方法
- 返回当前线程
// 当前线程
[NSThread currentThread];
NSLog(@"%@", [NSThread currentThread]);
// 如果number=1,则表示在主线程,否则是子线程
打印结果:{number = 1, name = main}
- 阻塞睡眠
//休眠多久
[NSThread sleepForTimeInterval:2];
//休眠到指定时间
[NSThread sleepUntilDate:[NSDate date]];
- 其他
//退出线程
[NSThread exit];
//判断当前线程是否为主线程
[NSThread isMainThread];
//判断当前线程是否是多线程
[NSThread isMultiThreaded];
//主线程的对象
NSThread *mainThread = [NSThread mainThread];
- NSThread相关属性
//线程是否在执行
thread.isExecuting;
//线程是否被取消
thread.isCancelled;
//线程是否完成
thread.isFinished;
//是否是主线程
thread.isMainThread;
//线程的优先级,取值范围0.0到1.0,默认优先级0.5,1.0表示最高优先级,优先级高,CPU调度的频率高
thread.threadPriority;
注意:线程优先级和线程执行顺序之间不是必然关系
六、 GCD(Grand Central Dispatch)
- Dispatch Queue(队列)
队列种类 | 说明 |
---|---|
串行队列(DISPATCH_QUEUE_SERIAL) | 按FIFO的顺序执行,一个任务执行完成才会执行下一个任务 |
并发队列(DISPATCH_QUEUE_CONCURRENT) | 任务无序同时执行 |
执行方式 | 说明 |
---|---|
同步执行 | 任务都在当前线程中执行,并且会阻塞当前线程 |
异步执行 | 任务会在开辟的新线程中执行,不会阻塞当前线程 |
组合方式 | 说明 |
---|---|
串行同步队列 | 任务都在当前线程执行(同步),并且顺序执行(串行) |
串行异步队列 | 任务都在开辟的新的子线程中执行(异步),并且顺序执行(串行) |
并发同步队列 | 任务都在当前线程执行(同步),但是是顺序执行的(并发的特性并没有体现出来) |
并发异步队列 | 任务在开辟的多个子线程中执行(异步),并且是同时执行的(并发) |
- 创建队列:
/**
串行队列:serial_queue1
*/
dispatch_queue_t serial_queue1 = dispatch_queue_create("com.seral.queue", DISPATCH_QUEUE_SERIAL);
/**
串行队列:serial_queue2
*/
dispatch_queue_t serial_queue2 = dispatch_queue_create("com.seral.queue", NULL);
/**
并发队列:concurrent_queue
*/
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
/**
主队列(串行队列):main_queue
*/
dispatch_queue_t main_queue = dispatch_get_main_queue();
/**
全局队列(并发队列):global_queue
*/
dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
- 组合方式说明
(1) 串行同步队列
dispatch_queue_t serial_queue = dispatch_queue_create("com.serial.queue", NULL);
dispatch_sync(serial_queue, ^{
NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(serial_queue, ^{
NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(serial_queue, ^{
NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});
结果:
--- 1 --- {number = 1, name = main} ---
--- 2 --- {number = 1, name = main} ---
--- 3 --- {number = 1, name = main} ---
(2) 串行异步队列
dispatch_queue_t serial_queue = dispatch_queue_create("com.serial.queue", NULL);
dispatch_async(serial_queue, ^{
NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});
结果:
--- 1 --- {number = 3, name = (null)} ---
--- 2 --- {number = 3, name = (null)} ---
--- 3 --- {number = 3, name = (null)} ---
(3) 并发同步队列
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(concurrent_queue, ^{
NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(concurrent_queue, ^{
NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_sync(concurrent_queue, ^{
NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});
结果:
--- 1 --- {number = 1, name = main} ---
--- 2 --- {number = 1, name = main} ---
--- 3 --- {number = 1, name = main} ---
(4) 并发异步队列
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrent_queue, ^{
NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});
结果:
--- 3 --- {number = 4, name = (null)} ---
--- 1 --- {number = 3, name = (null)} ---
--- 2 --- {number = 5, name = (null)} ---
- 队列组
作用:队列组是用来管理队列中任务的执行
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_async(group, concurrent_queue, ^{
NSLog(@"--- 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_group_async(group, concurrent_queue, ^{
NSLog(@"--- 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_group_async(group, concurrent_queue, ^{
NSLog(@"--- 3 --- %@ ---", [NSThread currentThread]);
});
dispatch_group_notify(group, concurrent_queue, ^{
NSLog(@"到这里就结束了!");
});
结果:
--- 2 --- {number = 8, name = (null)} ---
--- 3 --- {number = 3, name = (null)} ---
--- 1 --- {number = 7, name = (null)} ---
- Barrier
(1) 通过 barrier 添加的 block ,会等其之前添加的所有 block 执行完毕再执行
(2) 在 barrier 之后添加的 block ,会等其添加的 block 执行完毕再执行
(3) 只在自定义创建的并发队列有效
dispatch_queue_t concurrent_queue = dispatch_queue_create("com.concurrent.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrent_queue, ^{
NSLog(@"--- reading 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
NSLog(@"--- reading 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
NSLog(@"--- reading 3 --- %@ ---", [NSThread currentThread]);
});
/**
此处使用 dispatch_barrier_sync,block任务在当前线程中执行
*/
dispatch_barrier_async(concurrent_queue, ^{
NSLog(@"--- writing 0 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(concurrent_queue, ^{
NSLog(@"--- reading 4 --- %@ ---", [NSThread currentThread]);
});dispatch_async(concurrent_queue, ^{
NSLog(@"--- reading 5 --- %@ ---", [NSThread currentThread]);
});dispatch_async(concurrent_queue, ^{
NSLog(@"--- reading 6 --- %@ ---", [NSThread currentThread]);
});
结果:
--- reading 2 --- {number = 11, name = (null)} ---
--- reading 1 --- {number = 13, name = (null)} ---
--- reading 3 --- {number = 14, name = (null)} ---
--- writing 0 --- {number = 14, name = (null)} ---
--- reading 5 --- {number = 13, name = (null)} ---
--- reading 4 --- {number = 14, name = (null)} ---
--- reading 6 --- {number = 11, name = (null)} ---
全局队列中:
dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(global_queue, ^{
NSLog(@"--- reading 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(global_queue, ^{
NSLog(@"--- reading 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(global_queue, ^{
NSLog(@"--- reading 3 --- %@ ---", [NSThread currentThread]);
});
dispatch_barrier_async(global_queue, ^{
NSLog(@"--- writing 0 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(global_queue, ^{
NSLog(@"--- reading 4 --- %@ ---", [NSThread currentThread]);
});dispatch_async(global_queue, ^{
NSLog(@"--- reading 5 --- %@ ---", [NSThread currentThread]);
});dispatch_async(global_queue, ^{
NSLog(@"--- reading 6 --- %@ ---", [NSThread currentThread]);
});
结果:
--- reading 1 --- {number = 12, name = (null)} ---
--- reading 2 --- {number = 10, name = (null)} ---
--- writing 0 --- {number = 11, name = (null)} ---
--- reading 3 --- {number = 13, name = (null)} ---
--- reading 4 --- {number = 6, name = (null)} ---
--- reading 5 --- {number = 8, name = (null)} ---
--- reading 6 --- {number = 7, name = (null)} ---
串行队列中:
dispatch_queue_t serial_queue = dispatch_queue_create("com.serial.queue", NULL);
dispatch_async(serial_queue, ^{
NSLog(@"--- reading 1 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
NSLog(@"--- reading 2 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
NSLog(@"--- reading 3 --- %@ ---", [NSThread currentThread]);
});
dispatch_barrier_async(serial_queue, ^{
NSLog(@"--- writing 0 --- %@ ---", [NSThread currentThread]);
});
dispatch_async(serial_queue, ^{
NSLog(@"--- reading 4 --- %@ ---", [NSThread currentThread]);
});dispatch_async(serial_queue, ^{
NSLog(@"--- reading 5 --- %@ ---", [NSThread currentThread]);
});dispatch_async(serial_queue, ^{
NSLog(@"--- reading 6 --- %@ ---", [NSThread currentThread]);
});
结果:
--- reading 1 --- {number = 4, name = (null)} ---
--- reading 2 --- {number = 4, name = (null)} ---
--- reading 3 --- {number = 4, name = (null)} ---
--- writing 0 --- {number = 4, name = (null)} ---
--- reading 4 --- {number = 4, name = (null)} ---
--- reading 5 --- {number = 4, name = (null)} ---
--- reading 6 --- {number = 4, name = (null)} ---
- Semaphore (信号量)
/**
创建方法:初始值必须 >= 0
*/
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
/**
等待一个信号
DISPATCH_TIME_NOW :不等待
DISPATCH_TIME_FOREVER :一直等待,直到收到信号
返回 0 为成功,非 0 就是超时
*/
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
/**
发送信号:信号量计数增加
*/
dispatch_semaphore_signal(semaphore);
实例1:多个网络请求并发执行
dispatch_queue_t global_queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t group = dispatch_group_create();
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
dispatch_group_async(group, global_queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(semaphore);
NSLog(@"--- 请求 1 ---");
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
});
dispatch_group_async(group, global_queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(semaphore);
NSLog(@"--- 请求 2 ---");
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
});
dispatch_group_async(group, global_queue, ^{
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
dispatch_semaphore_signal(semaphore);
NSLog(@"--- 请求 3 ---");
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
});
dispatch_group_notify(group, global_queue, ^{
NSLog(@"--- 请求全部完成! ---");
});
结果:
--- 请求 3 ---
--- 请求 2 ---
--- 请求 1 ---
--- 请求全部完成! ---
实例2:多个网络请求顺序执行
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_queue_t serial_queue = dispatch_queue_create("com.serial_queue", NULL);
dispatch_async(serial_queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"--- 请求 1 ---");
dispatch_semaphore_signal(semaphore);
});
});
dispatch_async(serial_queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"--- 请求 2 ---");
dispatch_semaphore_signal(semaphore);
});
});
dispatch_async(serial_queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"--- 请求 3 ---");
dispatch_semaphore_signal(semaphore);
});
});
结果:
--- 请求 1 ---
--- 请求 2 ---
--- 请求 3 ---
GitHub地址:Demo