八线程详解,iOS开采八线程之GCD

iOS开发多线程之GCDiOS开发之GCD同步任务加强iOS开发之GCD串行队列iOS开发之GCD并发队列

GCD的简单使用

什么是GCD

  • 全程是Grand Central Dispatch
  • 纯C语言,提供非常多强大的函数
  • 多核并行运算,不叫多线程,它只是完成了多线程的封装和使用

GCD的优势

  • GCD是苹果公司为多核的并行运算提出的解决方案;
  • iOS 4.0推出供开发者使用;
  • 使用GCD不关心线程,只要关心队列;线程的调度是由CPU调度,那么我们的CPU是有多核的。如果开发者去调度线程,那是否要考虑CPU的核数了?开发者是不是要考虑适配? 而你使用GCD,则不用动,所以开发者很便利。这就是苹果多它的CPU多核伏笔
  • GCD 会自动利用更多的CPU内核
  • GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
  • 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码

线程的串行

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

GCD的简单使用

什么是GCD

  • 全程是Grand Central Dispatch
  • 纯C语言,提供非常多强大的函数
  • 多核并行运算,不叫多线程,它只是完成了多线程的封装和使用

GCD的优势

  • GCD是苹果公司为多核的并行运算提出的解决方案;
  • iOS 4.0推出供开发者使用;
  • 使用GCD不关心线程,只要关心队列;线程的调度是由CPU调度,那么我们的CPU是有多核的。如果开发者去调度线程,那是否要考虑CPU的核数了?开发者是不是要考虑适配? 而你使用GCD,则不用动,所以开发者很便利。这就是苹果多它的CPU多核伏笔
  • GCD 会自动利用更多的CPU内核
  • GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)
  • 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码

任务和队列

GCD的2个核心概念

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

GCD的使用就2个步骤

  • 定制任务 将大象放进冰箱有几步?
  • 将任务添加到队列中

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

==画图分析==程序员要做的,将任务添加到队列;队列按照程序员指定的方式,调度任务。执行任务的方法:同步/异步同步:一个任务没有结束,就不会执行下一个任务异步:不用等待任务执行完毕,就会执行下一个任务

GCD有一个“线程池”;

  • GCD同步调度任务时,会拿出1根线程,让它执行队列中的任务。当一个任务执行完成后,就会再从队列一个一个的执行;
  • GCD异步调度任务时,首先拿出1根线程,让这个线程去处理一个任务;当任务开始执行,就再从线程池里,再获取一个线程去队列去顺序拿任务执行;指定线程最大并发数;当其中的线程执行任务完毕后,再去队列中按照FIFO原则获取任务;

图1:同步线程图例

图片 1Snip20170810_1.png图2:异步线程图例图片 2Snip20170810_2.png

在viewController 的touchBegain方法里去调用方法。[self gcdDemo1]

  • 在viewController里,gcdDemo1方法:

1.创建队列2.添加任务到队列中3.将任务添加到队列,并且会执行

写block的方法的窍门:写用函数的思路写出,太函数名前面加一个括号()和 尖尖符号,再在函数体外面的大括号{}前面加一个尖尖符号。

/*同步执行方法,这句话不执行完,就不会执行下个任务,同步执行不会开启线程;*/-gcdDemo1{ //1.创建队列 dispatch_queue_t q = dispatch_get_global_queue; //2.任务添加到队列中 //2.1定义任务--block void  = ^{ NSLog(@"%@",[NSThread curresntThread]); }; //2.2 添加任务到队列,并且会执行 dispatch_sync; //合并步骤1,2步,省略写法 dispatch_sync(q,^{ NSLog(@"%@",[NSThread currentThread]); }); }
  • 在viewController里异步执行任务,gcdDemo2方法:

1.创建队列2.添加任务到队列中3.将任务添加到异步队列,并且会执行

异步执行,如果任务没有执行完毕,可以不用等待;异步执行下一个任务。具备开启线程的能力,异步通常又是多线程的代名词!

/*异步任务*/-gcdDemo2{ //1.创建队列 dispatch_queue_t q = dispatch_get_global_queue; //2.1定义任务--block void  = ^{ NSLog(@"%@",[NSThread curresntThread]); }; //2.2 添加任务到队列,并且会执行 dispatch_async; }

多线程

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

任务和队列

GCD的2个核心概念

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

GCD的使用就2个步骤

  • 定制任务 将大象放进冰箱有几步?
  • 将任务添加到队列中

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

==画图分析==程序员要做的,将任务添加到队列;队列按照程序员指定的方式,调度任务。执行任务的方法:同步/异步同步:一个任务没有结束,就不会执行下一个任务异步:不用等待任务执行完毕,就会执行下一个任务

GCD有一个“线程池”;

  • GCD同步调度任务时,会拿出1根线程,让它执行队列中的任务。当一个任务执行完成后,就会再从队列一个一个的执行;
  • GCD异步调度任务时,首先拿出1根线程,让这个线程去处理一个任务;当任务开始执行,就再从线程池里,再获取一个线程去队列去顺序拿任务执行;指定线程最大并发数;当其中的线程执行任务完毕后,再去队列中按照FIFO原则获取任务;

图1:同步线程图例

图片 3

图2:异步线程图例

图片 4

在viewController 的touchBegain方法里去调用方法。[self gcdDemo1]

  • 在viewController里,gcdDemo1方法:

1.创建队列2.添加任务到队列中3.将任务添加到队列,并且会执行

写block的方法的窍门:写用函数的思路写出,太函数名前面加一个括号()和 尖尖符号,再在函数体外面的大括号{}前面加一个尖尖符号。

/*同步执行方法,这句话不执行完,就不会执行下个任务,同步执行不会开启线程;*/-gcdDemo1{ //1.创建队列 dispatch_queue_t q = dispatch_get_global_queue; //2.任务添加到队列中 //2.1定义任务--block void  = ^{ NSLog(@"%@",[NSThread curresntThread]); }; //2.2 添加任务到队列,并且会执行 dispatch_sync; //合并步骤1,2步,省略写法 dispatch_sync(q,^{ NSLog(@"%@",[NSThread currentThread]); });}
  • 在viewController里异步执行任务,gcdDemo2方法:

1.创建队列2.添加任务到队列中3.将任务添加到异步队列,并且会执行

异步执行,如果任务没有执行完毕,可以不用等待;异步执行下一个任务。具备开启线程的能力,异步通常又是多线程的代名词!

/*异步任务*/-gcdDemo2{ //1.创建队列 dispatch_queue_t q = dispatch_get_global_queue; //2.1定义任务--block void  = ^{ NSLog(@"%@",[NSThread curresntThread]); }; //2.2 添加任务到队列,并且会执行 dispatch_async;}

线程间的通讯

GCD之间的线程通讯

-gcdDemo3{ //指定任务执行方法 -- 异步 dispatch_async(dispatch_get_global_queue,^{ //耗时操作 NSLog(@"%@",[NSThread currentThread]); //更新UI dispatch_async(dispatch_get_main_Queue(),^{ NSLog(@"更新UI%@",[NSThread currentThread]); }); });}

==修改多线程demo 002--显示网络图片==

-viewDidLoad{ //代码集中,便于维护 //利用GCD获取网络图片 //异步执行 dispatch_async(dispatch_get_global_queue,^{ NSURL *url = [NSURL URLWithString:@"http://img3.utuku.china.com/395x0/news/20170629/35381bbe-6e16-4be1-8cf4-4af9107448b7.jpg"]; NSData *data = [NSData dataWithContentsOfURL:url]; UIImage *image = [UIImage imageWithData:data]; //更新UI dispatch_async(dispatch_get_main_queue(),^{ self.imageView.image = image; [self.imageView sizeToFit]; self.scrollView.contentSize = image.size; }); //block没有循环引用,只是一个代码块,因为它没有作为属性,这里的block用完就释放了。 });}

多线程的优缺点

  • 优点:

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

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

线程间的通讯

GCD之间的线程通讯

-gcdDemo3{ //指定任务执行方法 -- 异步 dispatch_async(dispatch_get_global_queue,^{ //耗时操作 NSLog(@"%@",[NSThread currentThread]); //更新UI dispatch_async(dispatch_get_main_Queue(),^{ NSLog(@"更新UI%@",[NSThread currentThread]); }); });}

==修改多线程demo 002--显示网络图片==

-viewDidLoad{ //代码集中,便于维护 //利用GCD获取网络图片 //异步执行 dispatch_async(dispatch_get_global_queue,^{ NSURL *url = [NSURL URLWithString:@"http://img3.utuku.china.com/395x0/news/20170629/35381bbe-6e16-4be1-8cf4-4af9107448b7.jpg"]; NSData *data = [NSData dataWithContentsOfURL:url]; UIImage *image = [UIImage imageWithData:data]; //更新UI dispatch_async(dispatch_get_main_queue(),^{ self.imageView.image = image; [self.imageView sizeToFit]; self.scrollView.contentSize = image.size; }); //block没有循环引用,只是一个代码块,因为它没有作为属性,这里的block用完就释放了。 });}

iOS中多线程的实现方案

  • pthread:

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

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

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

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

推荐文集

原文作者:集才华美貌于一身的—C姐

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:^{
}];

本文由星彩网app下载发布于计算机编程,转载请注明出处:八线程详解,iOS开采八线程之GCD

TAG标签: 星彩网app下载
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。