iOS线程基础知识总结
一， 程序、进程和线程
程序：由源代码生成的可执行应用
进程： 一个正在运行的程序可以看做是一个进程
线程：程序中独立运行的代码段。
一个进程是由一个或多个线程组成。进程只负责资源的调度和分配， 线程才是程序真正的执行单元， 负责代码的执行。
线程和进程的区别：
1， 地址空间：线程是进程内的一个执行单元；进程至少有一个线程， 他们共享进程的地址空间； 而地址有自己的独立的地址空间；
2， 资源拥有：进程是资源分配和拥有的单位， 同一个进程内的线程共享进程的资源；
3， 线程是处理器调度的基本单位， 而进程不是；
4， 二者都可以并发执行
**************iOS中关于UI的添加和刷新必须在主线程中操作
二， 多线程的实现种类
iOS中多线程的实现种类有：NSThread，NSObject，NSOperationQueue，GCD
1, NSThread是一个轻量级的多线程， 有以下两种创建方式：
(1)初始化开辟子线程
- (void)allocThread {
//初始化开辟子线程
//object 就是子线程方法的参数
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(threadAction:) object:@1000];
//*********初始化开辟线程的话需要手动开启
thread.name = @"zhengzhou";
// _thread.isCancelled 是否被取消
// _thread.isExecuting 是否正在执行
// _thread.isMainThread 是否是主线程
[thread start];
}
- (void)threadAction:(NSNumber *)number {
//使用NSThread开辟的子线程, 方法内部默认没有添加自动释放池, 为了防止内存泄露, 我们需要手动添加自动释放池
@autoreleasepool {
for (int i = 0; i < [number integerValue]; i++) {
NSLog(@"%@", [NSThread currentThread]);
if (i == 100) {
// cancle 并不能取消正在执行的线程，只能取消还没有开始执行的线程
[[NSThread currentThread] cancel];
// 立即停止线程
[NSThread exit];
}
NSLog(@"%d", i);
}
}
}
(2)便利构造器开辟子线程
//不需要手动开启
[NSThread detachNewThreadSelector:@selector(threadAction:) toTarget:self withObject:@1000];
我们一般不用NSThread来开辟子线程
2, NSObject
//NSObject
- (void)objectAction {
//开辟子线程
[self performSelectorInBackground:@selector(reuestImageData:) withObject:@100];
}
//子线程方法
- (void)reuestImageData:(NSString *)string {
//手动添加自动释放池
@autoreleasepool {
//回到主线程刷新UI
//最后一个参数为YES时， 是等主线程的方法执行完之后在执行线程后面的方法
//最后一个参数为NO时， 是主线程和子线程中的方法同时执行
[self performSelectorOnMainThread:@selector(updateUI:) withObject:nil waitUntilDone:NO];
for (int i = 0; i < 10; i++) {
NSLog(@"%d********%@", i, [NSThread currentThread]);
}
}
}
//刷新UI
- (void)updateUI:(NSData *)data {
for (int i = 0; i < 10; i++) {
NSLog(@"%d+++++++++%@", i, [NSThread currentThread]);
}
}
3， NSOperationQueue
NSOperation在MVC中属于M，是用来封装单个任务相关的代码和数据的抽象类，不能够直接使用这个类，而是使用子类(NSInvocationOperation或NSBlockOperation)来执行实际任务。
只是一个操作，本身无主线程子线程之分，可在任意线程中使用。通常与NSOperationQueue结合使用，只是封装了一定的代码段和数据去实现一个功能。
- (void)invocationOperationAction {
//NSOperation的子类, 创建的操作和线程没有关系, 在主线程中创建的操作, 方法在主线程中进行, 在子线程中创建的操作在子线程中进行
NSInvocationOperation *operation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(invocationOperationMethod:) object:@"hello"];
//需要手动开启任务
[operation start];
//取消任务
// [operation cancel];
//是否正在执行
// [operation isExecuting];
//是否完成任务
// [operation isFinished];
}
- (void)invocationOperationMethod:(NSString *)string {
NSLog(@"%@", [NSThread currentThread]);
NSLog(@"%@", string);
}
// NSBlockOperation
- (void)blockOperation {
NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
//执行的方法
NSLog(@"%@", [NSThread currentThread]);
}];
//需要手动开启
[blockOperation start];
}
NSOperationQueue是操作队列, 用来管理一组Operation对象的执行, 会根据需要自动为Operation开辟合适数量的线程, 已完成任务的执行
其中NSOperation可以调节它在队列中的优先级(使用addDependency: 设置依赖关系)
当最大并发数设置为1的时候, 能实现线程同步(串行执行)
- (void)operationQueue {
NSBlockOperation *blockOperation1 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 1000000; i++) {
NSLog(@"1 ------ %d", i);
}
}];
NSBlockOperation *blockOperation2 = [NSBlockOperation blockOperationWithBlock:^{
for (int i = 0; i < 1000000; i++) {
NSLog(@"2 ------ %d", i);
}
}];
//创建一个新的队列
//新创建的队列, 里面的任务是并发执行的, 而且是在子线程中执行的
NSOperationQueue *queue = [[NSOperationQueue alloc] init];
//设置任务最大并发数, 如果为1, 队列里边的任务相当于串行
// queue.maxConcurrentOperationCount = 1;
//添加依赖关系, 必须在任务添加到队列之前设置
[blockOperation1 addDependency:blockOperation2];
[queue addOperation:blockOperation1];
[queue addOperation:blockOperation2];
}
4，GCD(Grand Central Dispatch)
是Apple开发的一种多核编程技术. 主要用于优化应用程序一支持多核处理器以及其他对称多处理系统
GCD提供函数实现多线程开发, 性能更高, 功能也更加强大
首次发布在Mac OS X 10.6, iOS4以上可用
核心概念:
任务: 具有一定功能的代码段, 一般是一个block或者函数， 与NSOperation一样，并无主线程与子线程之分，主要是看它加载在什么queue队列中
分发队列: GCD队列的方式进行工作
GCD会根据分发队列的类型, 创建合适数量的线程执行队列中的任务
dispatch queue有串行队列和并发队列两种：
(1)串行队列(SerialQueue)：一次只执行一个任务. 一般用于同步访问特定的资源和数据. 当创建多个SerialQueue时, 虽然他们是同步执行的, 但他们之间是并发执行的.SerialQueue能实现线程同步
//主队列
- (void)mainQueueAction {
//获取主队列
dispatch_queue_t queue = dispatch_get_main_queue();
//主队列中添加任务
dispatch_async(queue, ^{
for (int i = 0; i < 100; i++) {
NSLog(@"-------------------%@", [NSThread mainThread]);
}
});
//主队列中添加任务
dispatch_async(queue, ^{
for (int i = 0; i < 100; i++) {
NSLog(@"++++++++++++++++++++%@", [NSThread mainThread]);
}
});
}
//自定义串行队列
- (void)customSerialQueue {
//创建一个串行队列
//参数:(1)队列的名字, (2)队列类型, 是串行还是并行
//串行里面的任务是在同一个线程中执行的
dispatch_queue_t serialQueue = dispatch_queue_create("com.lanou3g.serialQueue", DISPATCH_QUEUE_SERIAL);
dispatch_async(serialQueue, ^{
for (int i = 0; i < 100; i++) {
NSLog(@"---------------------%@", [NSThread currentThread]);
}
});
dispatch_async(serialQueue, ^{
for (int i = 0; i < 100; i++) {
NSLog(@"++++++++++++++++++++%@", [NSThread currentThread]);
}
});
}
(2)并发队列(Concurrent):可以并发地执行多个任务
//全局队列
- (void)globalQueue {
//参数: (1)参数优先级, (2)预留参数
//队列里面的任务并发执行
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//添加任务
dispatch_async(globalQueue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"----------%@", [NSThread currentThread]);
}
});
dispatch_async(globalQueue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"+++++++++++%@", [NSThread currentThread]);
}
});
}
//自定义并发队列
- (void)customConcurrentQueue {
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.lanou3g.concurrentQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(concurrentQueue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"------------------%@", [NSThread currentThread]);
}
});
dispatch_async(concurrentQueue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"+++++++++++++++++++%@", [NSThread currentThread]);
}
});
}
(3)GCD功能
GCD功能
dispatch_async() //往队列中添加任务, 任务会排队执行
dispatch_after() //往队列中添加任务, 任务不但会排队, 还会在延迟的时间点执行
//延迟执行任务
- (void)delayPerformQueue {
dispatch_queue_t queue = dispatch_queue_create("com.lanou3g.delayPerformQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"%@", [NSThread currentThread]);
}
});
//延迟执行任务
//queue队列里面的任务执行完成之后, 延迟5秒执行该函数里面的任务
//不能在主队列中执行该任务
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), queue, ^{
NSLog(@"延迟执行的任务");
});
}
dispatch_apply() //往队列中添加任务, 任务会重复执行n次
//重复执行任务
- (void)repeatPerformTask {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//注意: queue 参数不能是主队列(死锁)
dispatch_apply(10, queue, ^(size_t index) {
NSLog(@"%ld, %@", index, [NSThread currentThread]);
});
}
dispatch_group_async()//将任务添加到队列中, 并添加分组标记
dispatch_group_notify() //将任务添加到队列中, 当某个分组的所有任务执行完之后, 此任务才会执行
//分组标记功能
- (void)groupTask {
dispatch_queue_t queue = dispatch_queue_create("waige", DISPATCH_QUEUE_CONCURRENT);
//创建分组
dispatch_group_t group = dispatch_group_create();
//往队列里面添加任务1
dispatch_group_async(group, queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"------------%@", [NSThread currentThread]);
}
});
//往队列里面添加任务2
dispatch_group_async(group, queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"+++++++++++++++%@", [NSThread currentThread]);
}
});
//给队列添加任务, 并添加分组标记
dispatch_group_notify(group, queue, ^{
NSLog(@"queue里面的所有任务都已经执行完毕");
});
}
dispatch_barrier_async() //将任务添加到队列中, 此任务执行的时候, 其他任务停止执行
//添加障碍
- (void)barrierFunction {
//创建队列
dispatch_queue_t queue = dispatch_queue_create("waige", DISPATCH_QUEUE_CONCURRENT);
//添加任务
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"写入数据");
}
});
//设置屏障, 队列里面前面的任务执行完之后才执行屏障函数里面的任务
dispatch_barrier_async(queue, ^{
for (int i = 0; i < 20; i++) {
NSLog(@"不要打扰我, 哥在写数据呢");
}
});
//屏障函数的任务完成之后才会执行下面的任务
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"写完了, 大家可以读数据了");
}
});
}
dispatch_once() //任务添加到队列中, 但任务在程序运行过程中, 只执行一次
可用于单例的创建
该函数接收一个dispatch_once用于检查该代码块是否已经被调度的谓词(是一个长整型, 实际上作为BOOL使用), 它在接收一个希望在应用的生命周期内仅被调度一次的代码块. 不仅意味着代码仅会被运行一次, 而且还是线程安全的, 这就意味着你不需要使用诸如@synchronized之类的来防止使用多个线程或者队列时不同步的问题
+ (instancetype)sharedSingleTon {
static SingleTon *singleTon = nil;
//只能同时允许一个线程访问
@synchronized(self) {
if (singleTon == nil) {
singleTon = [[SingleTon alloc] init];
}
}
return singleTon;
}
//GCD创建单例
+ (instancetype)defaultSingleTon {
static SingleTon *single = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
//这里的代码只执行一次
single = [[SingleTon alloc] init];
});
return single;
}
dispatch_sync() //将任务添加到队列中, block不执行完, 下面代码不会执行(同步),会阻塞当前线程 ----------在当前线程中执行
dispatch_async_f() //将任务添加到队列中, 任务是函数非block（异步）---------重新创建线程执行任务
//同步
- (void)useOfSync {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//dispatch_sync会阻塞当前线程
dispatch_sync(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"%@", [NSThread currentThread]);
}
});
NSLog(@"这是一条分割线");
dispatch_sync(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"=====%@", [NSThread currentThread]);
}
});
NSLog(@"这又是一条分割线");
}
三，线程间的通信
子线程回到主线程的方法
//bool参数 如果是YES, 子线程会等待主线程的任务完成以后才会继续执行, 如果为NO, 主线程的任务没有结束的时候就会执行子线程的任务
[self performSelectorOnMainThread:@selector(updataUI:) withObject:data waitUntilDone:NO];
dispatch_async(dispatch_get_main_queue(), ^{
self.imageView.image = [UIImage imageWithData:data];
});
[[NSOperationQueue mainQueue] addOperationWithBlock:^{
self.imageView.image = [UIImage imageWithData:data];
}];
四，线程互斥
对线程并行编程中, 线程间的同步和互斥是一个很有技巧的也很容易出错的地方。
多线程操作同一个资源(即某个对象), 需要保证线程在对资源的状态(即对象的成员变量)进行一些非原子性操作后, 状态仍然正确。
情景: 三个售票窗口同时售票, 可只剩最后一张票, 如何解决
解决方案
1，@synchronized 自动对参数对象加锁, 保证临街区内的代码线程安全
2，NSLock
//创建一个并行队列
dispatch_queue_t queue = dispatch_queue_create("zz", DISPATCH_QUEUE_CONCURRENT);
//创建锁对象
NSLock *lock = [[NSLock alloc] init];
//开辟10个子线程, 进行售票
for (int i = 0; i < 10; i++) {
dispatch_async(queue, ^{
//加锁
[lock lock];
//售票任务
while (self.ticketsCount > 0) {
//线程休息0.1秒
[NSThread sleepForTimeInterval:0.1];
//售出一张
self.ticketsCount--;
NSLog(@"剩余票数:%ld, 当前线程:%@", self.ticketsCount, [NSThread currentThread]);
}
//解锁
[lock unlock];
});
}
3，NSConditionLock条件锁 可以设置条件
//创建一个并行队列
dispatch_queue_t queue = dispatch_queue_create("zz", DISPATCH_QUEUE_CONCURRENT);
//条件锁
NSConditionLock *lock = [[NSConditionLock alloc] initWithCondition:2];;
//开辟10个子线程, 进行售票
for (int i = 0; i < 10; i++) {
dispatch_async(queue, ^{
//条件锁
[lock lockWhenCondition:2];
//售票任务
while (self.ticketsCount > 0) {
//线程休息0.1秒
[NSThread sleepForTimeInterval:0.1];
//售出一张
self.ticketsCount--;
NSLog(@"剩余票数:%ld, 当前线程:%@", self.ticketsCount, [NSThread currentThread]);
}
//解锁
[lock unlockWithCondition:2];
});
}
4，NSRecursiveLock 递归锁 多次调用不会阻塞以获取该锁的线程
//创建一个并行队列
dispatch_queue_t queue = dispatch_queue_create("zz", DISPATCH_QUEUE_CONCURRENT);
//递归锁
recursiveLock = [[NSRecursiveLock alloc] init];
//开辟10个子线程, 进行售票
for (int i = 0; i < 10; i++) {
dispatch_async(queue, ^{
//递归锁
[recursiveLock lock];
//售票任务
while (self.ticketsCount > 0) {
//线程休息0.1秒
[NSThread sleepForTimeInterval:0.1];
//售出一张
self.ticketsCount--;
NSLog(@"剩余票数:%ld, 当前线程:%@", self.ticketsCount, [NSThread currentThread]);
}
//解锁
[recursiveLock unlock];
});
}
五，总结
NSThread, NSOperationQueue, NSObject, GCD 都能实现多线程
1，GCD是苹果提供的性能更高的方式
使用多线程开发的优点: 资源利用率更好, 程序设计在某些情况下更简单, 程序响应更快
缺点: 多线程金环提升了性能, 但是存在一些访问限制, 比如线程同步, 线程互斥等; 多线程在使用的时候, 最终是要回到主线程刷新UI的, 如果开辟过多的多线程, 会造成CPU的消耗
2，NSOperationQueue和GCD 的区别
(1)GCD是基于C语言构成的API, 而NSoperationQueue是NSObject对象,在GCD 中在队列中执行的是由block构成的任务, 而NSOperationQueue有两种方式可供选择:NSInvocationOperation和NSBlockOperation
(2)在NSOperationQueue中可以随时取消正在等待执行队列, 而GCD无法停止已经加入queue队列的block块(其实是有的, 只不过代码比较复杂)
(3)在NSOperation中我们可以为任务设定依赖关系,
(4)我们可以讲KVO应用在NSOperation对象中, 可以监听一个operation是否完成或取消, 这样可以更有效的掌控我们的后台任务
(5)在NSOperation中我们可以设置NSOperation的priority的优先级, 能够使同一个并行的序列中的任务区分先后的执行, 而在GCD中, 我们只能区分不同任务队列的优先级, 如果要区分block任务的优先级, 也需要大量的代码
(6)我们能够对NSOperation进行继承, 在这智商添加成员变量与成员方法, 提高整个代码的复用度, 这笔简单地将block任务排入执行队列更有自由度, 能够在其之上添加更多自定制的功能
3，OperationQueue提供了更多在编写多线程程序时需要的功能, 并隐藏了许多线程调度, 线程取消与线程优先级的复杂代码, 为我们提供简单API入口. 从编程原则来说, 一般我们需要尽可能的使用最高等级, 封装完美的API, 在必须时才使用底层的API.
GCD更简洁, 性能更好,而NSOperationQueue为我们提供了更多的选择
