iOS开发之多线程（消息循环）

最新推荐文章于 2024-07-10 08:30:42 发布

猫南北学ios

最新推荐文章于 2024-07-10 08:30:42 发布

阅读量643

点赞数

分类专栏： iOS网络编程与多线程实战文章标签： ios

本文链接：https://blog.csdn.net/weixin_46926959/article/details/119004801

版权

iOS网络编程与多线程实战专栏收录该内容

11 篇文章 0 订阅

订阅专栏

运行速度

操作内存栈空间 > 操作内存堆空间 > I/O操作

同步和异步

同步：从上往下，依次执行，一次执行一个任务
异步：多人同时执行多个任务

进程和线程

进程：系统中的应用程序
线程：一个进程有多个线程（至少一个线程），线程是进程的基本执行单元，一个进程所有任务都在线程中执行

多线程的优缺点

优点

多线程可以解决程序阻塞问题，提高程序执行效率和资源利用率（cpu，内存），线程上的任务执行完成后，线程自动销毁

缺点

开启线程需要占用一定的内存空间（默认512KB）
开启大量线程会占用大量内存空间，降低程序性能
线程越多，cpu在调用线程的开销越大

主线程（UI线程）

主线程一般用来刷新UI界面，处理UI事件（比如：点击、滚动、拖拽等事件）
几乎所有UIKit提供的类都是线程不安全的，所有更新UI的操作都在主线程上执行
所有包含Mutable的类都是线程不安全的

别把耗时操作放进主线程

线程的状态

在这里插入图片描述

	NSThread为例
	阻塞状态
	[NSThread sleepForTimeInterval:3];
	线程退出 死亡状态 线程死亡/结束后不能再次使用，对象销毁了
	[NSThread exit];

线程的属性

	NSThread为例,有名字之后报错容易找到
	thread1.name = @"thread1";

	线程的优先级(0.0-1.0 默认0.5) 仅仅是分配的时间片更多
	thread1.threadPriority = 1.0;

多线程操作共享资源

	任意对象内部都有一把锁，默认开的 
	synchronized 同步
	互斥锁 -> 线程同步  
	@synchronized(self){
	//锁的代码
	}

property的atomic原子属性，自带自旋锁 保证同一时间多个线程能取值，但是只有一个能写入，单写多读

尽量将加锁、资源抢夺的业务逻辑交给服务端处理，减少客户端的压力

互斥锁和自旋锁

互斥锁：如果发现其他线程正在执行锁定代码，线程会进入体眠(就绪状态)，等其它线程时间片到打开锁后,线程会被唤醒(执行）
自旋锁：如果发现有其它线程正在锁定代码线程会用死循环的方式，一直等待锁定的代码执行完成，自旋锁更适合执行不耗时的代码

消息循环

Runloop就是消息循环，每一个线程内部都有一个消息循环
只有主线程的消息循环默认开启，子线程的消息循环默认不开启

消息循环的目的

保证程序不退出
负责处理输入事件
如果没有事件发生，会让程序进入休眠状态
线程池的实现原理，开启线程后永不销毁，当需要让子线程执行新的方法，使用 performSelector让指定的方法在指定的子线程上运行

	子线程的消息循环
	NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(demo:) object:@"参数"];
	[thread start];

	往子线程的消息循环添加输入源
	[self performSelector:@selector(demo1) onThread:thread withObject:nil waitUntilDone:NO];

-(void)demo:(NSString *)name{
	NSLog(@"Hello!";
	开始子线程的消息循环,如果开启，消息循环会一直运行
	如果消息循环没有添加事件，消息循环会立即结束
	//[[NSRunLoop currentRunLoop] run];

	消息循环定时结束2s
	[[NSRunLoop currentRunLoop] runUnitlDate:[NSDate dateWithTimeIntervalSinceNow:2]];
	NSLog(@"end!";
}
-(void)demo1:(NSString *)name{
	NSLog(@"Hello!i am in runloop!";
}

IOS的多线程技术方案：pthread、NSThread、GCD、NSOperation

在这里插入图片描述

pthread 几乎不用（看看就好）

	pthread_create(pthread_t *restrict,const pthread_attr_t *restrict,void *(*)(void *),void *restrict);

	pthread_t *restrict    线程编号地址
	const pthread_attr_t *restrict    线程属性 NULL
	void *(*)(void *)      线程要执行的函数
	void *restrict         要执行的函数的参数
	函数的返回值int         0是成功 非0是失败（代表错误的原因）

#import <pthread/pthread.h>

pthread_t prthread;//线程编号
char *name = "test";
int result = pthread_create(&pthread,NULL,demo,name);

if(result==0){
	NSLog(@"成功");
	}else{
	NSLog(@"失败");
	}

void *demo(void *param){
	NSLog(@"hello @s",param);
	return NULL;
}

传入的参数是NSString的解决方法

//__bridge 桥接 桥接给ARC管理
//把OC中的对象、传递给C语言的函数，需要桥接

NSString *name = @"test";
pthread_create(&pthread,NULL,demo,(__bridge void*)(name)));

void *demo(void *param){
	//需要桥接回来
	NSString *name = (__bridge NSString *)(param);
	NSLog(@"hello @s",name);
	return NULL;
}

NSThread（常用来定位线程）

	返回当前线程id
	[NSThread currentThread];

	判断当前线程是否为主线程
	[NSThread isMainThread];

	线程暂停
	[NSThread sleepForTimeInterval:0.1];

第一种方法

	NSThread *thread = [[NSThread alloc] initWithTarget:(nonull id) selector:(nonnull SEL) object:(nullable id)];
	参数1:对象 参数2:方法 参数3：参数

	NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(demo:) object:@"参数"];
	需要开始线程
	[thread start];

-(void)demo:(NSString *)name{
	NSLog(@"Hello! %@",name);
}

第二种方法

	直接执行
	[NSThread detachNewThreadSelector:@selector(demo) toTarget:self withObject:nil]

第三种方法

	[self performSelectorInBackground:@selector(demo) withObject:nil];

回到主线程（线程间通讯）

	//主线程更新UI控件 线程间通讯
	//waitUntilDone:YES 会等待方法执行完毕
	[self performSelectorOnMainThread:@selector(updateUI:) withObject:img waitUntilDone:YES];

异步下载网络图片（NSThread）

	//初始化并适应屏幕大小
	self.scrollView = [[UIScrollView alloc] initWithFrame:[UIScreen mainScreen].bounds];
	self.imageView = [[UIImageView alloc] init];
	[self.scrollView addSubview:self.imageView];

	NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(downloadImage) object:nil];

-(void)downloadImage{
	NSURL *url = [NSURL URLWithString:@"图片URL"];
	NSDate *data = [NSData dataWithContentsOfURL:url];
	//二进制数据转化为图片
	UIImage *img = [UIImage imageWithData:data];
	//主线程更新UI控件 线程间通讯
	//waitUntilDone:YES 会等待方法执行完毕
	[self performSelectorOnMainThread:@selector(updateUI:) withObject:img waitUntilDone:YES];
}

-(void)updateUI:(UIImage *)img{
	self.imageView.image = img;
	//大小和图片保持一致
	[self.imageView.frame sizeToFit];
	self.scrollView.contentSize = img.size;
}

GCD

GCD全称是 Grand Central Dispatch，纯C语言，提供了非常多强大的函数GCD的优势·

GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核(比如双核、四核)
GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程) 程序员只需要告诉 GCD想要执行什么任务,不需要编写任何线程管理代码

GCD的两个核心：任务和队列

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

方法一

	//1创建队列（全局队列）
	dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
	//2创建任务
	dispatch_block_t task = ^{
		NSLog(@hello,%@", [NSThread currentThread]);
	};
	//3异步执行
	dispatch_async(queue, task);

方法二简化方法

	dispatch_async(dispatch_get_global_queue(0, 0), ^{
		NSLog(@hello,%@", [NSThread currentThread]);
	});

回到主线程(同步执行)

	dispatch_async(dispatch_get_main_queue(), task);

GCD的队列可以分为两大类型

并发队列(Concurrent Dispatch Queue)可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)
并发功能只有在异步(dispatch_async)函数下才有效
串行队列(Serial Dispatch Queue)：让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)

	//串行队列，同步执行 不开新线程，任务按照顺序执行
	disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_SERIAL);

	dispatch_sync(queue,^{
		NSLog(@“Hello！”)
	});

	//串行队列，异步执行 开新线程，任务按照顺序执行
	disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_SERIAL);

	dispatch_async(queue,^{
		NSLog(@“Hello！”)
	});

	//并行队列，同步执行跟串行队列，同步执行一致，不开线程，并行无法实现，实际应用没用
	disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_CONCURRENT);

	dispatch_sync(queue,^{
		NSLog(@“Hello！”)
	});

	//并行队列，异步执行 开多个线程无序执行
	disapatch_queue_t queue = dispatch_queue_create("名字",DISPATH_QUEUE_CONCURRENT);

	dispatch_async(queue,^{
		NSLog(@“Hello！”)
	});

主队列,异步执行

不开线程，同步执行
主队列特点：如果主线程正在执行代码暂时不调度任务，等主线程执行结束后在执行任务
主队列又叫全局串行队列，主线程

	//主队列,异步执行 主线程，顺序执行
	dispatch_async(dispatch_get_main_queue(),^{
		NSLog(@“Hello！”)
	});

主队列，同步执行

程序执行不出来(死锁)
死锁的原因，当程序执行到下面这段代码的时候
主队列：如果主线程正在执行代码，就不调度任务
同步执行：如果第一个任务没有执行，就继续等待第一个任务执行成，再执行下一个任务此时互相等待，程序无法往下执行(死锁)

	//主队列，同步执行 死锁
	dispatch_async(dispatch_get_main_queue(),^{
		NSLog(@“Hello！”)
	});
	//解决方案：开子线程

全局队列

全局队列本质就是并发队列

	//第一个参数是优先级，即服务质量，默认0
	dispatch_get_global_queue(0, 0);

全局队列和发队列的区别
并发队列有名称,可以跟踪错误,全局队列没有
在ARC中不需要考虑释放内存, dispatch_release(q);不允许调用
在MRC中需要手动释放内存,并发队列是 create创建出来的在MRC中见到create就要 release,全局队列不需要release(只有一个）
一般我们使用全局队列

在这里插入图片描述

	dispatch_get_main_queue(); //主队列
	dispatch_get_global_queue(0,0);//全局并行队列
	dispatch_queue_create("名字",DISPATH_QUEUE_CONCURRENT);//并行队列
	dispatch_queue_create("名字",DISPATH_QUEUE_SERIAL);//串行队列

Barrier阻塞

主要用于在多个异步操僬完成之后,统一对非线程安全的对象进行更新

适合于大规模的IO操作
当访问数据库或文件的时候,更新数据的时候不能和其他更新或读取的操作在同一时间执行,可以使用调度组不过有点复杂。也可以使用dispatch_barrier_async解决
Barrier栅栏函数只能控制同一并发队列，并且拦不住全局并行队列

	dispatch_barrier_async(dispatch_get_global_queue(0,0),^{
		//这里说全局队列，其实是拦不住的
		//如果是正常的并行队列，等待队列中前面添加的任务执行完成，才会执行barrier代码
	});

调度组

执行完调度组再执行后面的内容

	//全局队列
	dispatch_queue_t queue = dispatch_get_global_queue(0,0);
	//调度组
	dispatch_group_t group = dispatch_group_create();

	//ARC不用写
	//dispatch_retain(group);

	dispatch_group_async(group,queue,^{
		NSLog(@"1");
	})
	dispatch_group_async(group,queue,^{
		NSLog(@"2");
	})

	//等待调度组，等队列任务全部执行完，执行后续代码，会阻塞进程（很少使用）
	dispatch_group_wait(group,DISPATCH_TIME_FOREVER);

	//所有任务执行完，获得通知
	dispatch_group_notify(group,dispatch_get_main_queue(),^{
		NSLog(@"ok");
	});

GCD的其他操作

延迟执行

	dispatch_after(dispatch_time(DISPATCH_TIME_NOW,(int64_T)(2*NSEC_PER_SEC)),dispatch_get_main_queue(),)^{
		//代码区
	};
	参数1:延迟多少时间 精确到纳秒 参数2:队列 参数3:任务

一次性执行

	在当前线程上执行，判断静态的全局变量默认为0，执行完为-1
	dispatch_once本身就是线程安全的
	static disapatch_once_t onceToken;
	dispatch_once(@onceToken,^{
		//代码区
	});

单例模式中的可用线程锁或者dispatch_once来判断，dispatch_once为佳，无需等待

+(instancetype)test{
	static id instance =nil;
	static disapatch_once_t onceToken;
	//下面这个GCD只会在onceToken为空时，执行
	dispatch_once(@onceToken,^{
  		if(instance==nil){
     		instance=[[self alloc]init];
		}
	});
}

NSOperation

NSOperation的作用

是OC语言中基于GCD的面向对象的封装
使用起来比GCD更加简单(面向时象)
提供了一些用GCD不好实现的功能
苹果推荐使用,使用 Nsoperation不用关心线程以及线程的生命周期

NSOperation的头文件

NSOperation是一个抽象类：不能直接使用(方法没有实现)，约束子类具有共同的属性和方法
NSOperation的子类：NSInvocationOperation，NSBlockOperation，自定义operation
NSOperationQueue队列

NSOperation和NSOperationQueue实现多线程的具体步骤

1.先将需要执行的操作封装到一个 NSOperation对象中
2.然后将 NSOperation对象添加到 NSOperationQueue中系统会自动将
NSOperationQueue中的NSOperation取出来
将取出的NSOperation封装的操作放到一条新线程中执行，异步执行

NSInvocationOperation

建NSInvocationOperation对象

	(id)initwithTarget: (id)target selector: (SEL)sel object: (id)arg;

调用 start方法开始执行操作

	(void)start;
	//一旦执行操作,就会调用target的sel方法

注意默认情况下,调用了start方法后并不会开一条新线程去执行操作,而是在当前线程同步执行操作只有将NSOperation放到一个 NSOperationQueue中,才会异步执行操作。

	NSInvocationOperation *op =[[NSInvocationOperation alloc]initWithTarget:self selector: @selector(demo) object:nil];
	//不会开启新线程
	[op start];

	//创建操作
	NSInvocationOperation *op =[[NSInvocationOperation alloc]initWithTarget:self selector: @selector(demo) object:nil];
	//队列
	NSOperationQueue queue = [[NSOperationQueue alloc] init];
	//把操作添加进队列
	[queue addOperation:op];

NSBlockOperation

创建NSBlockOperation对象

	+(id)blockOperationWithBlock: (void(^)(void))block;

通过 addexecution Block:方法添加更多的操作

	-(void)addExecutionBlock: (void(^)(void))block;

**注意:**只要NSBlockOperation封装的操作数>1,就会异步执行操作

	NSBlockOperation *op =[NSBlockOperation blockOperationwithBlock:^{
		NSLog("%@",[NSThread currentThread]);
	}];
	//更新op的状态,执行main方法
	[op start];//不会开新线程

	//队列
	NSOperationQueue queue = [[NSOperationQueue alloc] init];
	//操作
	NSBlockOperation *op =[NSBlockOperation blockOperationwithBlock:^{
		NSLog("%@",[NSThread currentThread]);
	}];
	//添加进队列
	[queue addOperation:op];

	可以化简，调用这个方法
	NSOperationQueue queue = [[NSOperationQueue alloc] init];
	[queue addOperationWithBlock:^{
		NSLog("%@",[NSThread currentThread]);
	}];

操作的completionBlock

	NSBlockOperation *op =[NSBlockOperation blockOperationwithBlock:^{
		NSLog("%@",[NSThread currentThread]);
	}];
	//会在操作完成之后开启一个新线程
	[op setCompletionBlock:^{
		NSLog("%@",[NSThread currentThread]);
	}];
	[self.queue addOperation:op];

线程间通讯，回到主线程

	[[NSOperationQueue mainQueue] addOperationWithBlock:^{
		//在主线程执行的代码
	}]
	//获取当前队列[NSOperationQueue currentQueue];

NSOperation VS GCD

GCD

GCD是iOS4.0推出的,主要针对多核cpu做了优化,是C语言的技术
GCD是将任务(block)添加到队列(串行/并行/全局/主队列),并且以同步/异步的方式执行任务的函数
GCD提供了一些 NSOperation不具备的功能：一次性执行，延迟执行，调度组

NSOperation

NSOperation是iOS2.0推出的,iOS4之后重写了NSOperation
NSOperation将操作(异步的任务)添加到队列(并发队列),就会执行指定操作的函数
NSOperation里提供的方便的操作：最大并发数，队列的暂定/继续，取消所有的操作，指定操作之间的依赖关系(GCD可以用同步实现)

NSOperation的最大并发数

同时执行的任务数，比如：同时开3个线程执行3个任务，并发数就3，但是不代表线程数是3

最大并发数的相关方法

	-(NSInteger)maxConcurrentOperationCount;
	-(void)setMaxConcurrentOperationCount:(NSInteger)cnt;

	queue.maxConcurrentOperationCount = 2;

执行的过程
1、把操作添加到队列 self.queue.addoperationwithblock
2、去线程池去取空闲的线程,如果没有就创建线程
3、把操作交给从线程池中取出的线程执行
4、执行完成后,把线程再放回线程池中
5、重复2,3,4知道所有的操作都执行完

NSOperation队列的暂停、取消、恢复

取消队列的所有操作

当前正在执行会继续执行，后续操作会取消
(void)cancelAlloperations;
提示:也可以调用NSOperation的-(void)cancel方法取消单个操作

暂停和恢复队列

	当前正在执行会继续执行，后续操作会暂停
	-(void)setSuspended:(B00L)b;//YES代表暂停队列,NO代表恢复队列
	-(BOOL)isSuspended;

	queue.suspended =YES;

	queue.operationCount是队列的操作数

NSOperation操作的优先级

设置 Nsoperation在 queue中的优先级,可以改变操作的执行优先级

	-(NSOperationQueuePriority)queuePriority;
	-(void)setQueuePriority:(NSOperationQueuePriority)p;

	//服务质量设置 最高
	op.qualityOfService = NSQualityOfServiceUserInteractive;

iOS8以后推荐使用服务质量 qualityOfService 服务质量本质就是优先级

NSOperation操作的依赖

Nsoperation之间可以设置依赖来保证执行顺序
依赖关系可以跨队列

	比如一定要让操作A执行完后,才能执行操作B,可以这么写
	[operationgB adddependency: operationA];
	//操作B依赖于操作A


	可以在不同queue的NSOperation之间创建依赖关系
	模拟软件升级过程:下载一解压一升级完成

	//队列
	NSOperationQueue queue = [[NSOperationQueue alloc] init];
	//操作
	NSBlockOperation *op1 =[NSBlockOperation blockOperationwithBlock:^{
		NSLog(@"1");
	}];
	NSBlockOperation *op2 =[NSBlockOperation blockOperationwithBlock:^{
		NSLog(@"2");
	}];
	NSBlockOperation *op3 =[NSBlockOperation blockOperationwithBlock:^{
		NSLog(@"3");
	}];

	//避免循环依赖，否则不会执行
	[op2 adddependency:op1];
	[op3 adddependency:op2];

	//添加进队列 批量添加
	[queue addOperation:@[op1,op2,op3] waitUntilFinished:NO];

猫南北学ios

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
iOS开发之多线程（消息循环）

运行速度操作内存栈空间 > 操作内存堆空间 > I/O操作同步和异步同步：从上往下，依次执行，一次执行一个任务异步：多人同时执行多个任务进程和线程进程：系统中的应用程序线程：一个进程有多个线程（至少一个线程），线程是进程的基本执行单元，一个进程所有任务都在线程中执行多线程的优缺点优点多线程可以解决程序阻塞问题，提高程序执行效率和资源利用率（cpu，内存），线程上的任务执行完成后，线程自动销毁缺点开启线程需要占用一定的内存空间（默认512KB）开启大量线程会占用大量内存
复制链接

扫一扫