多线程(188金宝搏上)

1.进程:

系统中正在运行的一个应用程序,每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内

  • 一个NSThread对象就代表一条线程
  • 创建、启动线程

1.NSTread

一个NSThread对象就代表一条线程

<1>创建、启动线程

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];[thread start];// 线程一启动,就会在线程thread中执行self的run方法

<2>主线程相关用法

+ (NSThread *)mainThread; // 获得主线程- (BOOL)isMainThread; // 是否为主线程+ (BOOL)isMainThread; // 是否为主线程

<3>获得当前线程
NSThread *current = [NSThread currentThread];

<4>线程的调度优先级

+ (double)threadPriority;+ (BOOL)setThreadPriority:(double)p;- (double)threadPriority;- (BOOL)setThreadPriority:(double)p;

调度优先级的取值范围是0.0 ~ 1.0,默认0.5,值越大,优先级越高

自己开发时,建议一般不要修改优先级

<5>线程的名字

- (void)setName:(NSString *)n;- (NSString *)name;

<6>创建线程后自动启动线程

[NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];

<7>隐式创建并启动线程

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

<8>启动线程

- (void)start; 

// 进入就绪状态 -> 运行状态。当线程任务执行完毕,自动进入死亡状态

<9>阻塞(暂停)线程

+ (void)sleepUntilDate:(NSDate *)date;+ (void)sleepForTimeInterval:(NSTimeInterval)ti;// 进入阻塞状态

<10>强制停止线程

+ (void)exit;// 进入死亡状态

注意:一旦线程停止(死亡)了,就不能再次开启任务

3.线程间通信

<1>什么叫做线程间通信
在1个进程中,线程往往不是孤立存在的,多个线程之间需要经常进行通信

<2>线程间通信的体现
1个线程传递数据给另1个线程
在1个线程中执行完特定任务后,转到另1个线程继续执行任务

<3>线程间通信常用方法

- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;

4.GCD

<1>什么是GCD
1.全称是Grand Central Dispatch,可译为“牛逼的中枢调度器”
2.纯C语言,提供了非常多强大的函数
<2>GCD的优势
1.GCD是苹果公司为多核的并行运算提出的解决方案
2.GCD会自动利用更多的CPU内核(比如双核、四核)
3.GCD会自动管理线程的声明周期(创建线程、调度任务、销毁线程)
4.程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码
<3>GCD的两个核心概念
1.任务;执行什么操作
2.队列:用来存放任务
<4>使用步骤
1.定制任务:确定想要做的事情
2.将任务添加到队列中

  • GCD会自动将队列中的任务取出,放到对应的线程中执行
  • 任务的取出遵循队列的FIFO原则:先进先出,后进后出

<5>GCD中有2个用来执行任务的函数
1.用同步的方式执行任务

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);
  • queue:队列
  • block:任务

2.用异步的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

3.同步和异步的区别

  • 同步:在当前线程中执行,必须马上执行任务
  • 异步:在另一条线程中执行,可以延时执行

<6>GCD的队列可以分为2大类型
1.并发队列(Concurrent Dispatch Queue)

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

2.串行队列(Serial Dispatch Queue)

  • 让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)

<7>有4个术语比较容易混淆:同步、异步、并发、串行
1.同步和异步决定了要不要开启新的线程

  • 同步:在当前线程中执行任务,不具备开启新线程的能力
  • 异步:在新的线程中执行任务,具备开启新线程的能力

2.并发和串行决定了任务的执行方式

  • 并发:多个任务并发(同时)执行
  • 串行:一个任务执行完毕后,再执行下一个任务

3.在UI中当前线程双核主线程,即同步是在主线程中执行任务的,而异步是在开辟子线程中执行任务

<8>并发(并行)队列
1.GCD默认已经提供了全局的并发队列,供整个应用使用,不需要手动创建

使用dispatch_get_global_queue函数获得全局的并发队列dispatch_queue_t dispatch_get_global_queue(dispatch_queue_priority_t priority, // 队列的优先级unsigned long flags); // 此参数暂时无用,用0即可dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 获得全局并发队列

2.全局并发队列的优先级

#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 // 后台

3.手动创建并行队列

dispatch_queue_t queue = dispatch_queue_create("abc", DISPATCH_QUEUE_SERIAL);

<9>GCD中获得串行有2种途径

1.使用dispatch_queue_create函数创建串行队列dispatch_queue_tdispatch_queue_create(const char *label, // 队列名称 dispatch_queue_attr_t attr); // 队列属性,一般用NULL即可dispatch_queue_t queue = dispatch_queue_create("cn.qianfeng.queue", NULL); // 创建dispatch_release(queue); // 非ARC需要释放手动创建的队列

2.使用主队列(跟主线程相关联的队列)

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

<10>各种队列的执行效果

columncolumn
全局并行队列
同步(sync)没有开启新线程;串行执行任务
异步(async)有开启新线程;并行执行任务

<11>从子线程回到主线程

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

<12>延时执行
1.iOS常见的延时执行有2种方式

调用NSObject的方法[self performSelector:@selector(run) withObject:nil afterDelay:2.0];// 2秒后再调用self的run方法

2.使用GCD函数

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ // 2秒后异步执行这里的代码...});

<13>一次性代码
使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{ // 只执行1次的代码(这里面默认是线程安全的) //可用于UI中创建单例});

<14>队列组
1.有这么1种需求

  • 首先:分别异步执行2个耗时的操作
  • 其次:等2个异步操作都执行完毕后,再回到主线程执行操作

2.如果想要快速高效地实现上述需求,可以考虑用队列组

dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 执行1个耗时的异步操作});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 执行1个耗时的异步操作});dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的异步操作都执行完毕后,回到主线程...});
  • NSThread的基本使用

一、进程与线程

2.多线程的安全问题

<1>资源共享
1块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源
比如多个线程访问同一个对象、同一个变量、同一个文件

当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题

<2>安全隐患解决
1.互斥锁使用格式
@synchronized(锁对象) { // 需要锁定的代码 }
注意:锁定1份代码只用1把锁,用多把锁是无效的

互斥锁的优缺点
优点:能有效防止因多线程抢夺资源造成的数据安全问题
缺点:需要消耗大量的CPU资源

互斥锁的使用前提:多条线程抢夺同一块资源

相关专业术语:线程同步
线程同步的意思是:多条线程按顺序地执行任务
互斥锁,就是使用了线程同步技术

2.atomic和nonatomic
<1>OC在定义属性时有nonatomic和atomic两种选择
自旋锁:
atomic:原子属性,为setter方法加锁(默认就是atomic)
nonatomic:非原子属性,不会为setter方法加锁

<2>nonatomic和atomic对比
atomic:线程安全,需要消耗大量的资源
nonatomic:非线程安全,适合内存小的移动设备

<3>自旋锁与互斥锁的异同:
互斥锁:@synchronized(){}
自旋锁:atomic修饰的属性,set方法中会添加自旋锁
共同点:当多个线程访问同一个资源的时候,通过加锁可以避免数据安全问题。
不同点:互斥锁,其他线程(除了当前正在访问数据的其他想要访问这个数据的线程)会处于阻塞状态(有一个再回到就绪状态的过程);自旋锁,其他线程处于无限循环的过程(不会有状态的改变)

<4>iOS开发的建议
所有属性都声明为nonatomic
尽量避免多线程抢夺同一块资源
尽量将加锁、资源抢夺的业务逻辑交给服务器端处理,减小移动客户端的压力

2.线程:

1个进程要想执行任务,必须得有线程(每一个进程至少要有一条线程);线程是进程的基本执行单元,一个进程(程序)的所有任务都在线程中执行
1个线程中执行任务是串行的,同一时间只能执行一个任务,顺序执行所有任务;

执行任务

  • GCD中有2个用来执行任务的常用函数

用同步的方式执行任务dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);queue:队列block:任务用异步的方式执行任务dispatch_async(dispatch_queue_t queue, dispatch_block_t block);GCD中还有个用来执行任务的函数:dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);在前面的任务执行结束后它才执行,而且它后面的任务等它执行完成之后才会执行,这个queue不能是全局的并发队列
  • 同步和异步的区别同步:只能在当前线程中执行任务,不具备开启新线程的能力异步:可以在新的线程中执行任务,具备开启新线程的能力

  • 队列的类型

  • GCD的队列可以分为2大类型

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

  • 串行队列(Serial Dispatch
    Queue)让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)

  • 有4个术语比较容易混淆:同步、异步、并发、串行

  • 同步和异步主要影响:能不能开启新的线程

  • 同步:只是在当前线程中执行任务,不具备开启新线程的能力

  • 异步:可以在新的线程中执行任务,具备开启新线程的能力

  • 并发和串行主要影响:任务的执行方式

  • 并发:允许多个任务并发执行

  • 串行:一个任务执行完毕后,再执行下一个任务

  • 并发队列

使用dispatch_queue_create函数创建队列dispatch_queue_tdispatch_queue_create(const char *label, // 队列名称 dispatch_queue_attr_t attr); // 队列的类型创建并发队列dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);GCD默认已经提供了全局的并发队列,供整个应用使用,可以无需手动创建使用dispatch_get_global_queue函数获得全局的并发队列dispatch_queue_t dispatch_get_global_queue(dispatch_queue_priority_t priority, // 队列的优先级unsigned long flags); // 此参数暂时无用,用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 // 低#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台
  • 串行队列

使用dispatch_queue_create函数创建串行队列// 创建串行队列(队列类型传递NULL或者DISPATCH_QUEUE_SERIAL)dispatch_queue_t queue = dispatch_queue_create("com.name", NULL); 使用主队列(跟主线程相关联的队列)主队列是GCD自带的一种特殊的串行队列放在主队列中的任务,都会放到主线程中执行使用dispatch_get_main_queue()获得主队列dispatch_queue_t queue = dispatch_get_main_queue();

188金宝搏 1

  • GCD基本知识

    01 两个核心概念-队列和任务02 同步函数和异步函数

  • GCD基本使用

01 异步函数+并发队列:开启多条线程,并发执行任务1.获取全局的并发队列 dispatch_queue_t queue = dispatch_get_global_queue; 2.添加任务到队列文档说明是FIFO原则, 先进先出打印结果不正确的原因: 线程的执行速度可能不一样, 有得快一些, 有的慢一些 dispatch_async(queue, ^{ NSLog(@"1 - %@", [NSThread currentThread]); }); dispatch_async(queue, ^{ NSLog(@"2 - %@", [NSThread currentThread]); }); dispatch_async(queue, ^{ NSLog(@"3 - %@", [NSThread currentThread]); });02 异步函数+串行队列:开启一条线程,串行执行任务 异步 + 串行 = 会创建新的线程, 但是只会创建一个新的线程, 所有的任务都在这一个新的线程中执行 异步任务, 会先执行完所有的代码, 再在子线程中执行任务- asyncSerial{ 1.创建队列 dispatch_queue_t queue = dispatch_queue_create("name", DISPATCH_QUEUE_SERIAL); 2.添加任务 dispatch_async(queue, ^{ NSLog(@"1 - %@", [NSThread currentThread]); }); dispatch_async(queue, ^{ NSLog(@"2 - %@", [NSThread currentThread]); }); dispatch_async(queue, ^{ NSLog(@"3 - %@", [NSThread currentThread]); }); NSLog(@"%s", __func__);}03 同步函数+并发队列:不开线程,串行执行任务 同步 + 并行 = 不会开启新的线程 注意: 能不能开启新的线程, 和并行/串行没有关系, 只要函数是同步还是异步- syncConcurrent{ // 1.创建队列 dispatch_queue_t queue = dispatch_get_global_queue; // 2.添加任务 dispatch_sync(queue, ^{ NSLog(@"1 - %@", [NSThread currentThread]); }); dispatch_sync(queue, ^{ NSLog(@"2 - %@", [NSThread currentThread]); }); dispatch_sync(queue, ^{ NSLog(@"3 - %@", [NSThread currentThread]); }); NSLog(@"%s", __func__);}04 同步函数+串行队列:不开线程,串行执行任务 同步 + 串行 = 不会创建新的线程 注意: 如果是同步函数, 只要代码执行到了同步函数的那一行, 就会立即执行任务, 只有任务执行完毕才会继续往后执行- syncSerial{ // 1.创建队列 正是因为线程默认就是串行, 所以创建串行队列的时候, 队列类型可以不传值 // dispatch_queue_t queue = dispatch_queue_create("name", DISPATCH_QUEUE_SERIAL); dispatch_queue_t queue = dispatch_queue_create("name", NULL); // 2.添加任务 dispatch_sync(queue, ^{ NSLog(@"1 - %@", [NSThread currentThread]); }); dispatch_sync(queue, ^{ NSLog(@"2 - %@", [NSThread currentThread]); }); dispatch_sync(queue, ^{ NSLog(@"3 - %@", [NSThread currentThread]); }); NSLog(@"%s", __func__);}05 异步函数+主队列:不开线程,在主线程中串行执行任务- asyncMain{ 主队列, 只要将任务放到主队列中, 那么任务就会在主线程中执行 dispatch_queue_t queue = dispatch_get_main_queue(); 如果任务放在主队列中, 哪怕是异步方法也不会创建新的线程 dispatch_async(queue, ^{ NSLog(@"1 - %@", [NSThread currentThread]); }); dispatch_async(queue, ^{ NSLog(@"2 - %@", [NSThread currentThread]); }); dispatch_async(queue, ^{ NSLog(@"3 - %@", [NSThread currentThread]); });}06 同步函数+主队列:不开线程,串行执行任务 同步 + 主队列 = 需要记住的就一点: 同步函数不能搭配主队列使用 注意: 如果是在子线程中调用同步函数 + 主对列 是可以执行的- syncMian{ // 主队列, 只要将任务放到主队列中, 那么任务就会在主线程中执行 dispatch_queue_t queue = dispatch_get_main_queue(); // 需要记住的就一点: 同步函数不能搭配主队列使用 dispatch_sync(queue, ^{ NSLog(@"1 - %@", [NSThread currentThread]); }); dispatch_sync(queue, ^{ NSLog(@"2 - %@", [NSThread currentThread]); }); dispatch_sync(queue, ^{ NSLog(@"3 - %@", [NSThread currentThread]); }); NSLog(@"++++++++++++++");}07 注意同步函数和异步函数在执行顺序上面的差异
  • GCD线程间通信

 //0.获取一个全局的队列 dispatch_queue_t queue = dispatch_get_global_queue; //1.先开启一个线程,把下载图片的操作放在子线程中处理 dispatch_async(queue, ^{ //2.下载图片 NSURL *url = [NSURL URLWithString:@"http://h.hiphotos.baidu.com/zhidao/pic/item/6a63f6246b600c3320b14bb3184c510fd8f9a185.jpg"]; NSData *data = [NSData dataWithContentsOfURL:url]; UIImage *image = [UIImage imageWithData:data]; NSLog(@"下载操作所在的线程--%@",[NSThread currentThread]); //3.回到主线程刷新UI dispatch_async(dispatch_get_main_queue(), ^{ self.imageView.image = image; //打印查看当前线程 NSLog(@"刷新UI---%@",[NSThread currentThread]); }); });
  • GCD其它常用函数

 01 栅栏函数(控制任务的执行顺序) dispatch_barrier_async(queue, ^{ NSLog(@"--dispatch_barrier_async-"); }); 02 延迟执行(延迟·控制在哪个线程执行) dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (2.0 * NSEC_PER_SEC)), dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ NSLog(@"---%@",[NSThread currentThread]); }); iOS常见的延时执行 调用NSObject的方法 [self performSelector:@selector withObject:nil afterDelay:2.0]; // 2秒后再调用self的run方法 使用GCD函数 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ // 2秒后执行这里的代码...}); 使用NSTimer[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector userInfo:nil repeats:NO]; 03 一次性代码(注意不能放到懒加载) -once { //整个程序运行过程中只会执行一次 //onceToken用来记录该部分的代码是否被执行过 static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ NSLog; }); } 使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次 static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ // 只执行1次的代码(这里面默认是线程安全的)}); 04 快速迭代(开多个线程并发完成迭代操作) dispatch_apply(subpaths.count, queue, ^(size_t index) { }); 使用dispatch_apply函数能进行快速迭代遍历 dispatch_apply(10, dispatch_get_global_queue, ^(size_t index){ // 执行10次代码,index顺序不确定}); 05 队列组 //创建队列组 dispatch_group_t group = dispatch_group_create(); //队列组中的任务执行完毕之后,执行该函数 dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block); 有这么1种需求 首先:分别异步执行2个耗时的操作 其次:等2个异步操作都执行完毕后,再回到主线程执行操作 如果想要快速高效地实现上述需求,可以考虑用队列组dispatch_group_t group = dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 执行1个耗时的异步操作});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 执行1个耗时的异步操作});dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的异步操作都执行完毕后,回到主线程...}); 使用Crearte函数创建的并发队列和全局并发队列的主要区别:1.全局并发队列在整个应用程序中本身是默认存在的,并且对应有高优先级、默认优先级、低优先级和后台优先级一共四个并发队列,我们只是选择其中的一个直接拿来用。而Crearte函数是实打实的从头开始去创建一个队列。2.在iOS6.0之前,在GCD中凡是使用了带Crearte和retain的函数在最后都需要做一次release操作。而主队列和全局并发队列不需要我们手动release。当然了,在iOS6.0之后GCD已经被纳入到了ARC的内存管理范畴中,即便是使用retain或者create函数创建的对象也不再需要开发人员手动释放,我们像对待普通OC对象一样对待GCD就OK。3.在使用栅栏函数的时候,苹果官方明确规定栅栏函数只有在和使用create函数自己的创建的并发队列一起使用的时候才有效4.其它区别涉及到XUN内核的系统级线程编程,不一一列举。5.给出一些参考资料:GCDAPI:https://developer.apple.com/library/ios/documentation/Performance/Reference/GCD_libdispatch_Ref/index.html#//apple_ref/c/func/dispatch_queue_createLibdispatch版本源码:http://www.opensource.apple.com/source/libdispatch/libdispatch-187.5/

在想从网上下载的,显示真实的图片,必须在info.plist添加1个key

188金宝搏 2

多线程原理:

同一时间,CPU只能处理1条线程,只有1条线程在工作(执行);多线程并发(同时)执行,其实是CPU快速地在多条线程之间调度(切换)如果CPU调度线程的时间足够快,就造成了多线程并发执行的假象

  • 获得当前线程

4.多线程:

一个进程可以开启多条线程,每条线程可以并发(同时)执行不同的任务;多线程可以提高程序的执行效率

主线程的主要作用

<1>显示\刷新UI界面
<2>处理UI事件(比如点击事件、滚动事件、拖拽事件等)

NSThread *current = [NSThread currentThread];线程的名字- setName:(NSString *)n;- (NSString *)name;

5.NSOperation

<1>NSOperation的作用
1.配合使用NSOperation和NSOperationQueue也能实现多线程编程

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

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

3.NSOperation是个抽象类,并不具备封装操作的能力,必须使用它的子类

4.使用NSOperation子类的方式有3种

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

5.创建NSInvocationOperation对象

-(id)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;
  • 调用start方法开始执行操作

 -(void)start;

一旦执行操作,就会调用target的sel方法

注意:

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

6.创建NSBlockOperation对象

+(id)blockOperationWithBlock:(void (^)(void))block;
  • 通过addExecutionBlock:方法添加更多的操作

-(void)addExecutionBlock:(void (^)(void))block;
  • 注意:只要NSBlockOperation封装的操作数 > 1,就会异步执行操作

<2>NSOperationQueue的作用
1.NSOperation可以调用start方法来执行任务,但默认是同步执行的
2.如果将NSOperation添加到NSOperationQueue(操作队列)中,系统会自动异步执行NSOperation中的操作

  • 添加操作到NSOperationQueue中

-(void); addOperation:(NSOperation *)op-(void)addOperationWithBlock:(void (^)(void))block;

<3>什么是并发数
1.同时执行的任务数
2.比如,同时开3个线程执行3个任务,并发数就是3

  • 最大并发数的相关方法

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

<4>队列的取消、暂停、恢复
1.取消队列的所有操作

-(void)cancelAllOperations;提示:也可以调用NSOperation的- (void)cancel方法取消单个操作

2.暂停和恢复队列

-(void)setSuspended:(BOOL)b; // YES代表暂停队列,NO代表恢复队列-(BOOL)isSuspended;

<5>操作优先级
1.设置NSOperation在queue中的优先级,可以改变操作的执行优先级

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

2.优先级的取值

NSOperationQueuePriorityVeryLow = -8L,NSOperationQueuePriorityLow = -4L,NSOperationQueuePriorityNormal = 0,NSOperationQueuePriorityHigh = 4,NSOperationQueuePriorityVeryHigh = 8

<6>操作的监听
可以监听一个操作的执行完毕

-(void (^)(void))completionBlock;-(void)setCompletionBlock:(void (^)(void))block;

<7>操作依赖
1.NSOperation之间可以设置依赖来保证执行顺序

  • 比如一定要让操作A执行完后,才能执行操作B,可以这么写

[operationB addDependency:operationA]; // 操作B依赖于操作A

2.可以在不同queue的NSOperation之间创建依赖关系
3.注意:不能相互依赖

  • 比如A依赖B,B依赖A

<8>自定义NSOperation
1.自定义NSOperation的步骤很简单

  • 重写- (void)main方法,在里面实现想执行的任务

2.重写- (void)main方法的注意点

  • 自己创建自动释放池(因为如果是异步操作,无法访问主线程的自动释放池)
  • 经常通过- (BOOL)isCancelled方法检测操作是否被取消,对取消做出响应
  • a.特点:
  • 1)一套通用的多线程API
  • 2)适用于Unix\Linux\Windows等系统
  • 3)跨平台\可移植
  • 4)使用难度大
  • b.使用语言:c语言
  • c.使用频率:几乎不用
  • d.线程生命周期:由程序员进行管理

二、多线程技术

columncolumn
计数方案简介
pthread一套通用的多线程API,适用于Unix\Linux\Windows等系统,跨平台\可移植,使用难度大
NSTread使用更加面向对象,简单易用,可直接操作线程对象
GCD旨在代替NSTread等多线程技术,充分利用设备的多核
NSOperation基于GCD(底层是GCD),比GCD多了一些更简单使用的功能,使用更加面向对象
 + 创建pthread * pthread_create + 只要create一次就会创建一个新的线程 + 系统会自动在子线程中调用传入的函数 第一个参数: 线程的代号 第二个参数: 线程的属性 第三个参数: 指向函数的指针, 就是将来线程需要执行的方法 第四个参数: 给第三个参数的指向函数的指针 传递的参数 void *(*functionP) void * == id pthread_create(<#pthread_t *restrict#>, <#const pthread_attr_t *restrict#>, <#void *#>, <#void *restrict#>) 一般情况下C语言中的类型都是以 _t或者Ref结尾 pthread_t threadId; // 只要create一次就会创建一个新的线程 pthread_create(&threadId , NULL, &demo, "name");

5.主线程:

一个iOS程序运行后,默认会开启1条线程,称为“主线程”或“UI线程”

主线程的使用注意

<1>别将比较耗时的操作放到主线程中
<2>耗时操作会卡住主线程,严重影响UI的流畅度,给用户一种“卡”的坏体验

  • 设置线程的属性
启动线程- start; // 进入就绪状态 -> 运行状态。当线程任务执行完毕,自动进入死亡状态阻塞线程+ sleepUntilDate:date;+ sleepForTimeInterval:(NSTimeInterval)ti;// 进入阻塞状态强制停止线程+ exit;// 进入死亡状态注意:一旦线程停止了,就不能再次开启任务
- performSelectorOnMainThread:aSelector withObject:arg waitUntilDone:wait;- performSelector:aSelector onThread:(NSThread *)thr withObject:arg waitUntilDone:wait;
  • 进程
    • 进程是指在系统中正在运行的一个应用程序,每个进程之间是独立的,每个进程均运行在其专用且受保护的内存空间内
  • 线程

    • 1个进程要想执行任务,必须得有线程(每1个进程至少要有1条线程),一个进程的所有任务都在线程中执行
    • 线程的串行

      188金宝搏 3

//第一种方法 NSDate *start = [NSDate date]; //2.根据url地址下载图片数据到本地 NSData *data = [NSData dataWithContentsOfURL:url]; NSDate *end = [NSDate date]; NSLog(@"第二步操作花费的时间为%f",[end timeIntervalSinceDate:start]);//第二种方法 CFTimeInterval start = CFAbsoluteTimeGetCurrent(); NSData *data = [NSData dataWithContentsOfURL:url]; CFTimeInterval end = CFAbsoluteTimeGetCurrent(); NSLog(@"第二步操作花费的时间为%f",end - start);
  • 其他创建线程方式
  • 线程安全

     01 前提:多个线程访问同一块资源会发生数据安全问题 02 解决方案:加互斥锁 03 相关代码:@synchronized{} 04 专业术语-线程同步 05 原子和非原子属性(是否对setter方法加锁)
  • 线程间通信

  • NSThread
  • a.特点:
    • 1)使用更加面向对象
    • 2)简单易用,可直接操作线程对象
  • b.使用语言:OC语言
  • c.使用频率:偶尔使用
  • d.线程生命周期:由程序员进行管理

188金宝搏 4188金宝搏 5188金宝搏 6

  • 资源共享,1块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源,比如多个线程访问同一个对象、同一个变量、同一个文件,当多个线程访问同一块资源时,很容易引发数据错乱和数据安全问题
创建线程后自动启动线程[NSThread detachNewThreadSelector:@selector toTarget:self withObject:nil];隐式创建并启动线程[self performSelectorInBackground:@selector withObject:nil];上述2种创建线程方式的优缺点优点:简单快捷缺点:无法对线程进行更详细的设置
  • 线程的状态
  • 线程间通信示例

188金宝搏 7

NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector object:nil];[thread start];// 线程一启动,就会在线程thread中执行self的run方法主线程相关用法+ (NSThread *)mainThread; // 获得主线程- isMainThread; // 是否为主线程+ isMainThread; // 是否为主线程

188金宝搏 8188金宝搏 9

  • 图例

  • 在1个进程中,线程往往不是孤立存在的,多个线程之间需要经常进行通信

  • 线程间通信的体现,1个线程传递数据给另1个线程,在1个线程中执行完特定任务后,转到另1个线程继续执行任务

  • 线程间通信常用方法

  • OC在定义属性时有nonatomic和atomic两种选择atomic:原子属性,为setter方法加锁(默认就是atomic)nonatomic:非原子属性,不会为setter方法加锁

  • 原子和非原子的选择

  • nonatomic和atomic对比atomic:线程安全,需要消耗大量的资源nonatomic:非线程安全,适合内存小的移动设备

  • iOS开发的建议,所有属性都声明为nonatomic,尽量避免多线程抢夺同一块资源,尽量将加锁、资源抢夺的业务逻辑交给服务器端处理,减小移动客户端的压力

  • 图示

    188金宝搏 10188金宝搏 11

  • 互斥锁使用格式@synchronized { // 需要锁定的代码
    }注意:锁定1份代码只用1把锁,用多把锁是无效的

  • 互斥锁的优缺点优点:能有效防止因多线程抢夺资源造成的数据安全问题缺点:需要消耗大量的CPU资源

  • 互斥锁的使用前提:多条线程抢夺同一块资源

  • 相关专业术语:线程同步线程同步的意思是:多条线程在同一条线上执行互斥锁,就是使用了线程同步技术

//第一种创建线程的方式:alloc init.//特点:需要手动开启线程,可以拿到线程对象进行详细设置 //创建线程 /* 第一个参数:目标对象 第二个参数:选择器,线程启动要调用哪个方法 第三个参数:前面方法要接收的参数(最多只能接收一个参数,没有则传nil) */ NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector object:@"wendingding"]; //启动线程 [thread start];//第二种创建线程的方式:分离出一条子线程//特点:自动启动线程,无法对线程进行更详细的设置 /* 第一个参数:线程启动调用的方法 第二个参数:目标对象 第三个参数:传递给调用方法的参数 */ [NSThread detachNewThreadSelector:@selector toTarget:self withObject:@"我是分离出来的子线程"];//第三种创建线程的方式:后台线程//特点:自动启动线程,无法进行更详细设置[self performSelectorInBackground:@selector withObject:@"我是后台线程"];

-touchesBegan:(nonnull NSSet<UITouch *> *)touches withEvent:(nullable UIEvent *)event{// [self download2]; //开启一条子线程来下载图片 [NSThread detachNewThreadSelector:@selector(downloadImage) toTarget:self withObject:nil];}-downloadImage{ //1.确定要下载网络图片的url地址,一个url唯一对应着网络上的一个资源 NSURL *url = [NSURL URLWithString:@"http://图片的url地址"]; //2.根据url地址下载图片数据到本地(二进制数据 NSData *data = [NSData dataWithContentsOfURL:url]; //3.把下载到本地的二进制数据转换成图片 UIImage *image = [UIImage imageWithData:data]; //4.回到主线程刷新UI //4.1 第一种方式// [self performSelectorOnMainThread:@selector(showImage:) withObject:image waitUntilDone:YES]; //4.2 第二种方式// [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:YES]; //4.3 第三种方式 [self.imageView performSelector:@selector(setImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];}
 //设置线程的属性 //设置线程的名称 thread.name = @"线程A"; //设置线程的优先级,注意线程优先级的取值范围为0.0~1.0之间,1.0表示线程的优先级最高,如果不设置该值,那么理想状态下默认为0.5 thread.threadPriority = 1.0;
  • 同一时间,CPU只能处理1条线程,只有1条线程在工作多线程并发执行,其实是CPU快速地在多条线程之间调度,如果CPU调度线程的时间足够快,就造成了多线程并发执行的假象
  • 如果线程非常非常多,CPU会在N多线程之间调度,CPU会累死,消耗大量的CPU资源,每条线程被调度执行的频次会降低(线程的执行效率降低)

    188金宝搏 12

从子线程回到主线程dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 执行耗时的异步操作... dispatch_async(dispatch_get_main_queue(), ^{ // 回到主线程,执行UI刷新操作 });});
//线程的各种状态:新建-就绪-运行-阻塞-死亡//常用的控制线程状态的方法[NSThread exit];//退出当前线程[NSThread sleepForTimeInterval:2.0];//阻塞线程[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2.0]];//阻塞线程//注意:线程死了不能复生
  • 多线程的优点能适当提高程序的执行效率能适当提高资源利用率(CPU、内存利用率)

  • 多线程的缺点创建线程是有开销的,iOS下主要成本包括:内核数据结构、栈空间(子线程512KB、主线程1MB,也可以使用-setStackSize:设置,但必须是4K的倍数,而且最小是16K),创建线程大约需要90毫秒的创建时间,如果开启大量的线程,会降低程序的性能,线程越多,CPU在调度线程上的开销就越大,程序设计更加复杂:比如线程之间的通信、多线程的数据共享

简介

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

  • GCD中有2个核心概念

  • 任务:执行什么操作

  • 队列:用来存放任务

  • GCD的使用就2个步骤

  • 定制任务

  • 确定想做的事情

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

  • 1个进程中可以开启多条线程,多条线程可以并行执行不同的任务,进程 
    车间,线程车间工人,多线程技术可以提高程序的执行效率,比如同时开启3条线程分别下载3个文件(分别是文件A、文件B、文件C)

    188金宝搏 13

  • 如何计算代码段的执行时间

  • 主线程
    • 1)一个iOS程序运行后,默认会开启1条线程,称为“主线程”或“UI线程”。
    • 2)作用。刷新显示UI,处理UI事件。
  • 使用注意
    • 1)不要将耗时操作放到主线程中去处理,会卡住线程。
    • 2)和UI相关的刷新操作必须放到主线程中进行处理

相关文章

Comment ()
评论是一种美德,说点什么吧,否则我会恨你的。。。