iOS开发之多线程：Pthread、NSThread、GCD、N

作者: DB001 | 来源:发表于2020-04-20 15:16 被阅读0次

进程

什么是进程？

进程是指在系统中 正在运行 的一个应用程序。
每个进程之间是 独立 的，每个进程均运行在其专用且受保护的内存空间内。
比如同时打开QQ音乐、Xcode，系统就会分别启动2个进程
thread-01.png

通过“活动监视器”可以查看Mac系统中所开启的进程

线程

什么是线程？

1个进程要想执行 任务，必须得有线程 （每1个进程至少要有1条线程）。
线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行。
比如使用酷狗播放音乐、使用迅雷下载电影，都需要在线程中执行
thread-02.png

线程的串行

1个线程中任务的执行是 串行 的;
如果要在1个线程中执行多个任务，那么只能一个一个地按顺序执行这些任务;
也就是说，在同一时间内，1个线程只能执行1个任务。
比如在1个线程中下载3个文件（分别是文件A、文件B、文件C）
thread-03.png
因此，也可以认为 线程是进程中的1条执行路径

进程和线程的比较

线程是CPU调用(执行任务)的最小单位。

进程是CPU分配资源和调度的单位。

一个程序可以对应多个进程，一个进程中可以有多个线程，但至>少要有一个线程。

同一个进程内的线程共享进程的资源。

多线程

基本概念

1个进程中可以开启多条线程，每条线程可以 并行（同时）执行不同的任务。

线程的并行：

并行即同时执行。
比如同时开启3条线程分别下载3个文件（分别是文件A、文件B、文件C）
thread-04.png

多线程并发执行的原理：

同一时间，CPU只能处理1条线程，只有1条线程在工作（执行）。

多线程并发（同时）执行，其实是CPU快速地在多条线程之间 调度（切换）。

如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象。

思考：如果线程非常非常多，会发生什么情况？

1.CPU会在N多线程之间调度，CPU会累死，消耗大量的CPU资源。
2.每条线程被调度执行的频次会降低（线程的执行效率降低）。

多线程的优缺点：

优点

1、能适当提高程序的执行效率。
2、能适当提高资源利用率（CPU、内存利用率）。

缺点

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

多线程在iOS开发中的应用

主线程：

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

主线程的主要作用：

a、显示\刷新UI界面。

b、处理UI事件（比如点击事件、滚动事件、拖拽事件等）。

`主线程的使用注意！`

a、不要将比较耗时的操作放到主线程中（耗时操作会卡住主线程，严重影响UI的流畅度，给用户一种“卡”的坏体验）。

b、UI必须放在主线程中处理。

耗时操作的执行

a、如果将耗时操作放在 主线程。
thread-05.png

问题在哪？

1.在用户点击按钮5秒后才给出反应

b、如果将耗时操作放在 子线程（后台线程、非主线程）。
thread-06.png
好处在哪？

1.在用户点击按钮那一刻就有反应。
2.能同时处理耗时操作和用UI控件的事件。

iOS开发中多线程的实线方案

技术方案	简介	语言	线程生命周期	使用频率
pthread	a.一套通用的多线程API b.适用于Unix\Linux\Windows等系统; c.跨平台\可移植 d.使用难度大	C	程序员管理	几乎不用
NSThread	a.使用更加面向对象 b.简单易用，可直接操作线程对象	OC	程序员管理	偶尔使用
GCD	a.旨在替代NSThread等线程技术 b.充分利用设备的多核	C	自动管理	`经常使用`
NSOperation	a.基于GCD（底层是GCD） b.比GCD多了一些更单实用的功能 c.使用更加面向对象	OC	自动管理	`经常使用`

pthread

pthread的基本使用

#import "ViewController.h"
#import <pthread.h>

@interface ViewController ()

@end

@implementation ViewController

- (IBAction)btnClick:(id)sender {
    
    NSLog(@"mainThread:%@",[NSThread mainThread]);
    
    //pthread创建线程,执行任务
    //01 包含头文件
    //02 创建线程对象
    
    pthread_t thread = nil;
    
    //03 创建线程,执行任务
    /* 参数说明
     *
     * 第一个参数:线程对象 传地址
     * 第二个参数:线程的属性 (优先级)
     * 第三个参数:指向函数的指针
     * 第四个参数:传给第三个参数的(参数)
     */
    pthread_create(&thread, NULL, run, NULL);
}

//技巧:(*)改写成函数的名称,补全参数
void *run(void *str)
{
    //NSLog(@"run-------%@",[NSThread currentThread]);
    
    //把耗时操作放在子线程中执行
    for (int i = 0; i < 1000000; ++i) {
        NSLog(@"%zd---%@",i,[NSThread  currentThread]);
    }
    
    return NULL;
}
//$\color{red}{正在运行}$
@end

NSThread

一个NSThread对象就代表一条线程
主线程相关用法

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

获得当前线程

NSThread *current = [NSThread currentThread];

创建、启动线程：

创建线程方式1

/**
 * 需要手动调用 start方法开启线程
 */
-(void)createThread1
{
    //01 创建线程对象
    /* 参数说明
     *
     * 第一个参数:目标对象
     * 第二个参数:方法选择器 要执行的任务(方法)
     * 第三个参数:调用函数需要传递的参数
     */
    NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(run) object:nil];
    
    //02 启动线程
    [thread start];
}

创建线程方式2

//创建线程后自动启动线程
-(void)createThread2
{
    //直接分离出一条子线程
    [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
}

创建线程方式3

//隐式创建并启动线程
-(void)createThread3
{
    //开启后台线程
    [self performSelectorInBackground:@selector(run) withObject:nil];
}

三种创建线程方式对比

方式1：代码量更大|能够拿到线程对象（需要手动开启）
方式2：分离出子线程（不需要手动开启），无法拿到线程对象进行详细设置（名字|优先级）
方式3：开启后台线程 （不需要手动开启），无法拿到线程对象进行详细设置（名字|优先级）

线程的属性设置(名称|优先级)：

//设置线程的名字
- (void)setName:(NSString *)name;
- (NSString *)name;

//设置线程的优先级  `范围 0.0~1.0`
// 默认是0.5 
//1.0最高的
//优先级更高的线程,被CPU调度到的概率会更高
- (void)setThreadPriority:(double)priority;
- (double)threadPriority;

线程的生命周期：当线程内部的任务执行完毕会被释放
线程的状态

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

thread-07.png

控制线程状态

启动线程
- (void)start; 
// 进入就绪状态 -> 运行状态。当线程任务执行完毕，自动进入死亡状态

阻塞（暂停）线程
+ (void)sleepUntilDate:(NSDate *)date;
+ (void)sleepForTimeInterval:(NSTimeInterval)ti;
// 进入阻塞状态

强制停止线程
+ (void)exit;
// 进入死亡状态

注意：一旦线程停止（死亡）了，就不能再次开启任务

多线程的安全隐患

a、资源共享
1>1块资源可能会被多个线程共享，也就是“多个线程可能会同一时间访问同一块资源”。
2>比如多个线程访问同一个对象、同一个变量、同一个文件。

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

安全隐患分析

thread-08.png
安全隐患解决 – 互斥锁

thread-09.png
互斥锁：
1.互斥锁使用格式

为代码添加同步锁(互斥锁)
/*
 * token:锁对象 (要使用全局的对象) 建议直接使用self
 * {}   要加锁的代码段
 * 注意点:①加多把锁死无效的；②要注意加锁的位置
*/
@synchronized(token) { 
   // 需要锁定的代码  
}

注意：锁定1份代码只用1把锁，用多把锁是无效的。

2.互斥锁的优缺点

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

3.互斥锁的使用前提

多条线程可能存在同一时间抢夺同一块资源(即：多个线程同时访问同一个变量)。

4.相关专业术语：线程同步

a>`线程同步的意思是`：多条线程在同一条线上执行（按顺序地执行任务）。
b>互斥锁，就是使用了线程同步技术。

售票案例

#import "ViewController.h"

@interface ViewController ()

@property (strong, nonatomic)NSThread *threadA;
@property (strong, nonatomic)NSThread *threadB;
@property (strong, nonatomic)NSThread *threadC;

//票总数
@property (assign, nonatomic)NSInteger totalCount;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
    
    //初始化票总数
    self.totalCount = 100;
    
    self.threadA = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    
    self.threadB = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    
    self.threadC = [[NSThread alloc] initWithTarget:self selector:@selector(saleTickets) object:nil];
    
    self.threadA.name = @"售票员A";
    self.threadB.name = @"售票员B";
    self.threadC.name = @"售票员C";
   
    [self.threadA start];
    [self.threadB start];
    [self.threadC start];
    
}

- (void)saleTickets{
    
    while (1) {
        //为代码添加同步锁(互斥锁)
         /*
          * token:锁对象 (要使用全局的对象) 建议直接使用self
          * {} 要加锁的代码段
          * 注意点: ①加多把锁死无效的   ②要注意加锁的位置
          */
        //先加锁
        @synchronized (self) {
            
            //先读取余票数
            NSInteger count = self.totalCount;
            
            if (count>0) {
                
                //售出一张（重新写入）
                self.totalCount = count - 1;
                
//                for (NSInteger i = 0; i < 100000000; i++) {
//
//                }

                NSLog(@"%@售出一张票，余票：%zd",[NSThread currentThread].name,self.totalCount);
                
            }else{
                
                NSLog(@"%@:票已经售空",[NSThread currentThread].name);
                
                break;
            
            }
        }
    }
}

@end

线程间通信

什么叫做线程间通信?
1、在1个进程中，线程往往不是孤立存在的，多个线程之间需要经常进行通信。
线程间通信的体现：
1、1个线程传递数据给另1个线程。
2、在1个线程中执行完特定任务后，转到另1个线程继续执行任务。
线程间通信常用方法

  /* 参数说明
     *
     * 第一个参数:方法选择器  回到主线程要做什么(方法)
     * 第二个参数:调用函数需要传递的参数
     * 第三个参数:是否等待该方法执行完毕才继续往下执行 YES:等待
     */
- (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
- (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;

线程间通信案例

thread-10.png


#import "ViewController.h"

@interface ViewController ()
@property (weak, nonatomic) IBOutlet UIImageView *imageView;
@end

@implementation ViewController
- (void)viewDidLoad {
    [super viewDidLoad];
}
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event{
    
    //创建子线程方式一
//    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(downLoadImage) object:nil];
//    [thread start];
    
    //创建子线程方式二
    [NSThread detachNewThreadSelector:@selector(downLoadImage) toTarget:self withObject:nil];
    
    //创建子线程方式三（隐式创建线程）
//    [self performSelectorInBackground:@selector(downLoadImage) withObject:nil];
 
}
//执行下载任务
- (void)downLoadImage
{
    NSLog(@"---%@---",[NSThread currentThread]);
    
    NSURL *url = [NSURL URLWithString:@"https://ns-strategy.cdn.bcebos.com/ns-strategy/upload/fc_big_pic/part-00654-2651.jpg"];
    
    NSData *imageData = [NSData dataWithContentsOfURL:url];
    
    UIImage *image = [UIImage imageWithData:imageData];
      
    //回到主线程刷新UI界面
    /* 参数说明
       *
       * 第一个参数:方法选择器  回到主线程要做什么(方法)
       * 第二个参数:调用函数需要传递的参数
       * 第三个参数:是否等待该方法执行完毕才继续往下执行 YES:等待
       */
    //方式一
//    [self performSelectorOnMainThread:@selector(showImage:) withObject:image waitUntilDone:YES];
  
  //方式二
    [self performSelector:@selector(showImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];
    //方式三
//    [self.imageView performSelectorOnMainThread:@selector(setImage:) withObject:image waitUntilDone:YES];
}
//回到主线程刷新UI界面
- (void)showImage:(UIImage *)image{
    NSLog(@"---%@---",[NSThread currentThread]);
    self.imageView.image = image;
}
@end

原子和非原子属性

1、OC在定义属性时有nonatomic和atomic两种选择
2、atomic：原子属性，为setter方法加锁（默认就是atomic）
3、nonatomic：非原子属性，不会为setter方法加锁

原子和非原子属性的选择？

1、nonatomic和atomic对比
2、atomic：线程安全，需要消耗大量的资源
3、nonatomic：非线程安全，适合内存小的移动设备

iOS开发的建议

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

GCD

基本概念：

1、全称是Grand Central Dispatch，可译为牛逼的中枢调度器。
2、纯C语言，提供了非常多强大的函数。

GCD的优势

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

任务和队列

GCD中有2个核心概念
1、任务：执行什么操作。
2、队列：用来存放任务。
GCD的使用就2个步骤
1、定制任务：确定想做的事情。
2、将任务添加到队列中：（同步函数|异步函数）
a、GCD会自动将队列中的任务取出，放到对应的线程中执行;
b、任务的取出遵循队列的FIFO原则：先进先出，后进后出。
封装任务的函数:

1、同步函数dispatch_sync
a.不具备开启线程的能力，不能开线程
b.任务的执行方式：同步执行

2、异步函数dispatch_async
a.具备开启线程的能力，能开线程
b.任务的执行方式：异步执行

执行任务

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的队列可以分为2大类型：并发队列、串行队列

1.并发队列（Concurrent Dispatch Queue）
a.可以让多个任务并发（同时）执行自动开启多个线程同时执行任务
b.并发功能只有在异步dispatch_async函数下才有效

2.串行队列（Serial Dispatch Queue）
a.让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

队列的创建

使用dispatch_queue_create函数创建队列
/**
 *第一个参数： 队列名称 
 *第一个参数： 队列的类型
 */
dispatch_queue_t queue = dispatch_queue_create(const char *label, // 队列名称 
dispatch_queue_attr_t attr); // 队列的类型

创建并发队列

dispatch_queue_t queue = dispatch_queue_create("queue_Name", DISPATCH_QUEUE_CONCURRENT);

GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建

使用dispatch_get_global_queue函数获得全局的并发队列
/**
 *第一个参数： 队列的优先级
 *第一个参数： 此参数暂时无用，用0即可
 */
dispatch_queue_t queue = 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 (-2) // 低
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

创建串行队列

使用dispatch_queue_create函数创建串行队列

// 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）

dispatch_queue_t queue = dispatch_queue_create("queue_Name", NULL);

使用主队列（跟主线程相关联的队列）
1.主队列是GCD自带的一种特殊的串行队列。
2.放在主队列中的任务，都会放到主线程中执行。
3.使用dispatch_get_main_queue()获得主队列。
dispatch_queue_t queue = dispatch_get_main_queue();。

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

1.同步和异步主要影响：能不能开启新的线程
同步：只是在当前线程中执行任务，不具备开启新线程的能力

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

2.并发和串行主要影响：任务的执行方式
并发：允许多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务

GCD 的基本使用

#import "ViewController.h"

@interface ViewController ()

@end

@implementation ViewController

#pragma mark -----------------------
#pragma mark Events
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self syncConcurrent];
    //[self performSelectorInBackground:@selector(syncMain) withObject:nil];
}

#pragma mark -----------------------
#pragma mark GCD的基本使用(函数 + 队列)
//异步函数 + 并发队列:会开启多条子线程,所有的任务并发执行
//注意:开几条线程并不是由任务的数量决定的,是有GCD内部自动决定的
-(void)asyncConcurrent
{
    //01 创建队列
    /* 参数说明
     *
     * 第一个参数:C语言的字符串 给队列起个名字(建议:com.DB001.www.DownloadQueue)
     * 第二个参数:类型
     *          DISPATCH_QUEUE_CONCURRENT  并发队列
     *          DISPATCH_QUEUE_SERIAL      串行队列
     */
//创建并发队列
    //dispatch_queue_t queue = dispatch_queue_create("com.DB001.www.DownloadQueue", DISPATCH_QUEUE_CONCURRENT);

//获取全局并发队列
    //DISPATCH_QUEUE_PRIORITY_DEFAULT == 0 默认优先级
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    
     NSLog(@"-----start----");
    
    //02 封装任务,把任务添加到队列
    dispatch_async(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"5-----%@",[NSThread currentThread]);
    });
    
    
    NSLog(@"-----end----");
    
    
}

//异步函数 + 串行队列:会开启一条子线程,所有的任务在该子线程中串行执行
-(void)asyncSerial
{
    //01 创建队列
    /* 参数说明
     *
     * 第一个参数:C语言的字符串 给队列起个名字(建议:com.DB001.www.DownloadQueue)
     * 第二个参数:类型
     *          DISPATCH_QUEUE_CONCURRENT  并发队列
     *          DISPATCH_QUEUE_SERIAL      串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.DB001.www.DownloadQueue", DISPATCH_QUEUE_SERIAL);
    
    
    //02 封装任务,把任务添加到队列
    dispatch_async(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"5-----%@",[NSThread currentThread]);
    });
    
    
}

//同步函数 + 并发队列:不会开启子线程,所有的任务在当前线程中串行执行
-(void)syncConcurrent
{
    //01 创建队列
    /* 参数说明
     *
     * 第一个参数:C语言的字符串 给队列起个名字(建议:com.DB001.www.DownloadQueue)
     * 第二个参数:类型
     *          DISPATCH_QUEUE_CONCURRENT  并发队列
     *          DISPATCH_QUEUE_SERIAL      串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.DB001.www.DownloadQueue", DISPATCH_QUEUE_CONCURRENT);
    
    NSLog(@"-----start----");
    //02 封装任务,把任务添加到队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
   NSLog(@"-----end----");
    
}

//同步函数 + 串行队列:不会开启子线程,所有的任务在当前线程中串行执行
-(void)syncSerial
{
    //01 创建队列
    /* 参数说明
     *
     * 第一个参数:C语言的字符串 给队列起个名字(建议:com.DB001.www.DownloadQueue)
     * 第二个参数:类型
     *          DISPATCH_QUEUE_CONCURRENT  并发队列
     *          DISPATCH_QUEUE_SERIAL      串行队列
     */
    dispatch_queue_t queue = dispatch_queue_create("com.DB001.www.DownloadQueue", DISPATCH_QUEUE_SERIAL);
    
    
    //02 封装任务,把任务添加到队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
}

//异步函数 + 主队列:不会开线程,所有的任务都在主线程中串行执行
-(void)asyncMain
{
    //01 获得主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //02 封装任务并把任务添加到队列
    dispatch_async(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"5-----%@",[NSThread currentThread]);
    });

}

/**
  * 同步函数 + 主队列:
  * 这时会产生 -- “死锁”问题
  * 产生死锁的原因：是因为在主队列中的任务必须在主线程中执行，当主队列中有任务时，主队列就会安排主线程来执行任务，但是在调度之前会先检查主线程的状态（是否在忙）如果在忙就暂停调度直到主线程空闲位置；又因为是同步的方式在执行任务，任务1执行完之后才会执行之后的任务，这时主线程是繁忙的状态，会一直卡在执行任务1之前，出现了相互等待的现象（即死锁）
  * 解决“死锁”问题： [self performSelectorInBackground:@selector(syncMain) withObject:nil];
  */
-(void)syncMain
{
    //01 获得主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    NSLog(@"--------");
    //02 封装任务并把任务添加到队列
    dispatch_sync(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"5-----%@",[NSThread currentThread]);
    });
    
}

@end

任务的执行方式：
(1) 同步执行：必须等当前任务执行完毕，才能执行后面的任务
(2 )异步执行：不必须等当前任务执行完毕，就能执行后面的任务

各种组合情况:

同步函数 + 串行队列不会开线程,所有的任务在当前线程串行执行
同步函数 + 并发队列不会开线程,所有的任务在当前线程串行执行
同步函数 + 主队列死锁

异步函数 + 串行队列会开1条线程,所有的任务在子线程中串行执行;
异步函数 + 并发队列会开N条线程,所有的任务在子线程中并发执行 (⚠️ 线程的数量!= 任务的数量);
异步函数 + 主队列不会开线程,所有的任务在主线程串行执行。

总结:
开线程的情况:①异步函数 ② 不能是主队列
开几条线程:看队列,如果是并发队列那么就N条,如果是串行队列那么就开1条

各种队列的执行效果

	并发队列	手动创建的串行队列	主队列
同步（sync）	a.`没有`开启新线程 b.`串行`执行任务	a.`没有`开启新线程 b.`串行`执行任务	a.`没有`开启新线程 b.`串行`执行任务
异步（async）	a.`有`开启新线程 b.`并发`执行任务	a.`有`开启新线程 (仅开`1`条) b.`串行`执行任务	a.`没有`开启新线程 b.`串行`执行任务

注意
使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列

GCD的线程之间的通信

从子线程回到主线程

//获取全局并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
dispatch_async(queue, ^{
    // 执行耗时的异步操作...

      dispatch_async(dispatch_get_main_queue(), ^{
        // 回到主线程，执行UI刷新操作

        });
});

GCD的其他函数：

(1) 一次性代码 dispatch_once
(2) 延时执行 dispatch_after
(3) 快速迭代 dispatch_apply
(4) 栅栏函数 dispatch_barrier_async

(1) 一次性代码: dispatch_once
整个程序运行过程中只会执行一次 + 本身是线程安全
应用:单例模式

使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self once];
}

-(void)once
{
    static dispatch_once_t onceToken;
    NSLog(@"++++++%zd",onceToken);
    内部实现原理:判断onceToken的值 == 0 来决定是否执行block中的任务
    dispatch_once(&onceToken, ^{
        NSLog(@"once------");
    });
}

(2) 延时执行：dispatch_after
iOS常见的延时执行有三种方法：

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

2、使用GCD函数
dispatch_queue_t queue = dispatch_get_main_queue()“主队列”
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);“全局并发队列”
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), queue, ^{
// 2秒后执行这里的代码...
});

3、使用NSTimer
[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self delay];
}
-(void)delay
{
    NSLog(@"--delay-");
    //延迟执行
//    [self performSelector:@selector(run) withObject:nil afterDelay:2.0];
    
    [NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(run) userInfo:nil repeats:NO];
    
    //GCD中的延迟执行
    /* 参数说明
     *
     * 第一个参数:设置时间(GCD中的时间单位是纳秒)
     * 第二个参数:队列(决定block中的任务在哪个线程中执行,如果是主队列就是主线程,否在就在子线程)
     * 第三个参数:设置任务
     * 原理:(哪个简单)
     * A 先把任务提交到队列,然后等两秒再执行 错误
     * B 先等两秒,再把任务提交到队列        正确
     */
//    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_global_queue(0, 0), ^{
//        NSLog(@"-----GCD------%@",[NSThread currentThread]);
//    });
}

-(void)run
{
    NSLog(@"run--%@",[NSThread currentThread]);
}

(3) 快速迭代: dispatch_apply

使用dispatch_apply函数能进行快速迭代遍历
dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){
// 执行10次代码，index顺序不确定
});

//快速迭代(遍历)
-(void)apply
{
    //在当前线程中串行执行(提高效率)
    //1000  1   ==>10天
    //1000  10  ==>1天
    for (int i = 0; i < 10; ++i) {
        NSLog(@"%zd----%@",i,[NSThread currentThread]);
    }
    NSLog(@"____________");
    /* 参数说明
     *
     * 第一个参数:遍历的次数
     * 第二个参数:队列
     */
    //并发队列:会开启多条子线程和主线程一起并发的执行任务
    //主队列:死锁
    //普通的串行的队列:和for循环一样

    dispatch_queue_t queue = dispatch_queue_create("DownloadQueue", DISPATCH_QUEUE_SERIAL);
    
    dispatch_apply(10, queue, ^(size_t i) {
       
        NSLog(@"%zd----%@",i,[NSThread currentThread]);
    });
    
}

快速迭代的案例：将from文件夹中的文件剪切到to文件夹中
-(void)test2
{
    //01 获得文件夹的路径
    NSString *from = @"/Users/xiaomage/Desktop/from";
    NSString *to = @"/Users/xiaomage/Desktop/to";
    
    //02 获得该文件夹下面的所有文件
    NSArray *subPaths = [[NSFileManager defaultManager] subpathsAtPath:from];
    NSLog(@"%@",subPaths);
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_apply(subPaths.count, queue , ^(size_t i) {
        
        NSString *fileName = subPaths[i];
        
        //拼接文件的全路径
        NSString *fromFullPath = [from stringByAppendingPathComponent:fileName];
        NSString *toFullPath = [to stringByAppendingPathComponent:fileName];
        
        //执行文件的剪切操作
        [[NSFileManager defaultManager] moveItemAtPath:fromFullPath toPath:toFullPath error:nil];
        
        NSLog(@"%@--%@--%@",fromFullPath,toFullPath,[NSThread currentThread]);
        
    });
}

(4) 栅栏函数: dispatch_barrier_async

在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);
⚠️ 注意：这个queue不能是全局的并发队列

-(void)barrier
{
    //需求:有4个任务,要求开启多条线程来执行这些任务
    //增加需求:新的任务++++++,要求在12执行之后执行,要保证该任务执行完之后才能执行后面的34任务
    
    //栅栏函数:前面的任务并发执行,后面的任务也是并发执行
    //当前面的任务执行完毕之后，执行栅栏函数中的任务,等该任务执行完毕后再执行后面的任务
    //⚠️ 不能使用全局并发队列
    
    //01 获得队列
    dispatch_queue_t queue = dispatch_queue_create("Test", DISPATCH_QUEUE_CONCURRENT);
    //dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    //02 封装任务,并且添加到队列
    dispatch_async(queue, ^{
        NSLog(@"1-----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"2-----%@",[NSThread currentThread]);
    });
    
    //栅栏函数
    dispatch_barrier_async(queue, ^{
        NSLog(@"+++++++++++");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"3-----%@",[NSThread currentThread]);
    });
    
    
    dispatch_async(queue, ^{
        NSLog(@"4-----%@",[NSThread currentThread]);
    });
    
    
}

GCD的队列组：

基本概念：队列组是用来管理队列中任务的执行。
使用步骤:

创建队列组: dispatch_group_create();

创建队列:dispatch_queue_create(param1 , parame2);

使用队列组异步函数来封装任务, 然后提交到队列中dispatch_group_async(group, queue, ^{
});

把当前所有任务执行的情况, 都纳入到队列组监听的范围中

异步函数dispatch_async(queue, ^{ })和队列组dispatch_group_async(group, queue, ^{})的区别：

(1) dispatch_group_async(group, queue, ^{ });
1、封装任务
2 、把任务添加到队列
3 、监听任务的执行情况
(2) dispatch_async(queue, ^{ });
1 、封装任务
2 、把任务添加到队列

队列组的简单使用:监听任务的完成

1、所有的任务会并发的执行(不按序)。
2、所有的异步函数, 都是添加到队列中, 然后再纳入到队列组的监听范围。
3、使用dispatch_group_notify(队列组, 队列)函数, 来监听在这个函数上面的任务执行是否完成, 当任务完成, 就会调用这个方法。

案例需求：

需求1:4个任务,在子线程中并发执行,添加任务"+++++",必须等所有的任务都执行完再执行。

-(void)group{
1. 创建队列组
dispatch_group_t group = dispatch_group_create();
    
2. 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("Test", DISPATCH_QUEUE_CONCURRENT);

3.封装任务,添加到队列并监听任务的执行情况
 dispatch_group_async(group, queue, ^{
        NSLog(@"1---%@",[NSThread currentThread]);
 });
    
dispatch_group_async(group, queue, ^{
        NSLog(@"2---%@",[NSThread currentThread]);
});
    
dispatch_group_async(group, queue, ^{
        NSLog(@"3---%@",[NSThread currentThread]);
});

dispatch_group_async(group, queue, ^{
        NSLog(@"4---%@",[NSThread currentThread]);
});
4.拦截通知,当所有的任务都执行完毕后,执行++++操作
dispatch_group_notify(group, queue, ^{
        NSLog(@"++++++++%@",[NSThread currentThread]);
});
}

需求2:拦截多个队列中任务。

-(void)group{
1. 创建队列组
dispatch_group_t group = dispatch_group_create();
    
2. 创建并发队列
dispatch_queue_t queue = dispatch_queue_create("Test", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue1 = dispatch_queue_create("Test1", DISPATCH_QUEUE_CONCURRENT);

3.封装任务,添加到队列并监听任务的执行情况
 dispatch_group_async(group, queue, ^{
        NSLog(@"1---%@",[NSThread currentThread]);
 });
    
dispatch_group_async(group, queue, ^{
        NSLog(@"2---%@",[NSThread currentThread]);
});
    
dispatch_group_async(group, queue, ^{
        NSLog(@"3---%@",[NSThread currentThread]);
});

dispatch_group_async(group, queue1, ^{
        NSLog(@"4---%@",[NSThread currentThread]);
});
dispatch_group_async(group, queue1, ^{
        NSLog(@"5---%@",[NSThread currentThread]);
});

4.拦截通知,当所有的任务都执行完毕后,执行++++操作
dispatch_group_notify(group, queue, ^{
        NSLog(@"++++++++%@",[NSThread currentThread]);
});
}

探讨：
dispatch_group_notify内部是异步的执行
dispatch_group_notify队列:决定该block在哪个线程中处理(主:主线程非主队列:子线程)
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"++++++++%@",[NSThread currentThread]);
});

使用队列组的小实例 --- 下载两张图片, 然后合成后展示

- (void)downLoadTwoPicturesThenComposeOnePicture{
    //需求:开子线程下载两张图片,合成图片,显示出来
    //01 创建队列组
    dispatch_group_t group = dispatch_group_create();
    
    //02 获得并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
    //03 下载图片1
    dispatch_group_async(group, queue, ^{
        
        //001 url
        NSURL *URL = [NSURL URLWithString:@"http://pridelands.ru/pictures/real/puma/Cougar_018.jpg"];
        
        //002 Data
        NSData *imageData = [NSData dataWithContentsOfURL:URL];
        
        //003 转换
        self.image1 = [UIImage imageWithData:imageData];
        
          NSLog(@"Download1-----%@",[NSThread currentThread]);
    });
    
    //04 下载图片2
    dispatch_group_async(group, queue, ^{
        
        //001 url
        NSURL *URL = [NSURL URLWithString:@"http://m2.quanjing.com/2m/pust017/1574r-012067.jpg"];
        
        //002 Data
        NSData *imageData = [NSData dataWithContentsOfURL:URL];
        
        //003 转换
        self.image2 = [UIImage imageWithData:imageData];
        
          NSLog(@"Download2-----%@",[NSThread currentThread]);
        
    });
    
    //05 拦截通知,合成图片
    dispatch_group_notify(group, queue, ^{
        
        //001 开启上下文
        UIGraphicsBeginImageContext(CGSizeMake(300, 300));
        
        //002 画图1,2
        [self.image1 drawInRect:CGRectMake(0, 0, 150, 300)];
        [self.image2 drawInRect:CGRectMake(150, 0, 150, 300)];
        
        NSLog(@"Combie-----%@",[NSThread currentThread]);
        //003 根据上下文得到图片
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        
        //004 关闭上下文
        UIGraphicsEndImageContext();
        
        //06 显示图片(线程间通信)
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
            NSLog(@"UI-----%@",[NSThread currentThread]);
        });
    });
    
}

NSOperation 与 NSOperationQueue

NSOperation的作用

配合使用 NSOperation 和 NSOperationQueue 也能实现多线程编程。

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

先将需要执行的操作封装到一个NSOperation对象中

然后将NSOperation对象添加到NSOperationQueue中

系统会自动将NSOperationQueue中的NSOperation取出来

将取出的NSOperation封装的操作放到一条新线程中执行

NSOperation的子类
NSOperation是个抽象类，并不具备封装操作的能力，必须使用它的子类。
使用 NSOperation 子类有3种:

NSInvocationOperation

NSBlockOperation

自定义子类继承 NSOperation ，实现内部相应的方法

NSInvocationOperation

创建NSInvocationOperation对象.
-(id)initWithTarget:(id)target selector:(SEL)sel object:(id)arg;

调用start方法开始执行操作.
-(void)start;
一旦执行操作，就会调用target的sel方法.

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

-(void)invocationOperation
{
    //01 封装操作对象
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(download1) object:nil];
    
    //02 执行操作
     [op1 start];
}

NSBlockOperation

创建NSBlockOperation对象
+(id)blockOperationWithBlock:(void (^)(void))block;

-(void)blockOperation
{
    //操作:NSBlockOperation对象
    //任务:block
    
    //01 封装操作对象
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1----%@",[NSThread currentThread]);
    }];

    //02 执行操作
    [op1 start];
}

通过addExecutionBlock:方法添加更多的操作
- (void)addExecutionBlock:(void (^)(void))block;
注意：只要NSBlockOperation封装的操作数 > 1，就会异步执行操作.

    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3----%@",[NSThread currentThread]);
    }];
    
    //追加任务
    //当一个操作中的任务数量>1的时候,就会开启子线程和当前线程一起执行任务
    [op3 addExecutionBlock:^{
        NSLog(@"4----%@",[NSThread currentThread]);
    }];
    
    [op3 addExecutionBlock:^{
        NSLog(@"5----%@",[NSThread currentThread]);
    }];

  [op3 start];

NSOperationQueue

NSOperationQueue的作用.

NSOperation可以调用start方法来执行任务，但默认是同步执行的.

如果将NSOperation添加到NSOperationQueue（操作队列）中，系统会自动异步执行NSOperation中的操作.

添加操作到NSOperationQueue中
-(void)addOperation:(NSOperation *)op;
-(void)addOperationWithBlock:(void (^)(void))block;

操作队列的基本使用(操作 + 队列)

-(void)invocationOperationWithQueue
{
    //01 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //02 封装操作
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(download1) object:nil];
    
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(download2) object:nil];
    
    NSInvocationOperation *op3 = [[NSInvocationOperation alloc]initWithTarget:self selector:@selector(download3) object:nil];
    
    //03 把操作添加到队列
    [queue addOperation:op1];  
    [queue addOperation:op2];
    [queue addOperation:op3];
    
}

注意:

开启几条子线程并不是由操作的数量决定的
-[queue addOperation:op1];该方法内部会自动的调用start方法执行任务

-(void)blockOperationWithQueue
{
    //01 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //02 封装操作对象
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3----%@",[NSThread currentThread]);
    }];
    
    //03 把操作添加到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
    
    //简便方法:该方法内部首先会把block中的任务封装成一个操作(Operation),然后把该操作直接添加到队列
    [queue addOperationWithBlock:^{
        NSLog(@"4----%@",[NSThread currentThread]);
    }];
    
}

简便方法:该方法内部首先会把block中的任务封装成一个操作(Operation),然后把该操作直接添加到队列
[queue addOperationWithBlock:^{
NSLog(@"4----%@",[NSThread currentThread]);
}];

最大并发数：同时执行的任务数

最大并发数的相关方法
-(NSInteger)maxConcurrentOperationCount;
-(void)setMaxConcurrentOperationCount:(NSInteger)cnt;

案例：让多个操作在子线程中顺序执行

把队列的最大并发数设置为 1 ，就可以达到多个操作在子线程中顺序执行的效果。

-(void)changeSerialQueue
{
    //01 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //02 封装操作对象
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3----%@",[NSThread currentThread]);
    }];
    
    
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"4----%@",[NSThread currentThread]);
    }];
    
    
    NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"5----%@",[NSThread currentThread]);
    }];
    
    //设置最大并发数对于任务数量大于1的操作是无效的
    //当操作中任务数量>1的时候,会开启多条子线程和当前线程一起工作
//    [op5 addExecutionBlock:^{
//        NSLog(@"6----%@",[NSThread currentThread]);
//    }];
//    
//    [op5 addExecutionBlock:^{
//        NSLog(@"7----%@",[NSThread currentThread]);
//    }];
    
    //设置最大并发数 == 同一时间最多有多少条线程在执行
    //maxConcurrentOperationCount == 0 不能执行任务
    //NSOperationQueueDefaultMaxConcurrentOperationCount = -1 -1指的是一个最大的值(表示不受限制)
    queue.maxConcurrentOperationCount = 1;
    
    //03 把操作添加到队列中
//    [queue addOperation:op1];
//    [queue addOperation:op2];
//    [queue addOperation:op3];
//    [queue addOperation:op4];
//    [queue addOperation:op5];
    

    [queue addOperations:@[op1,op2,op3,op4,op5] waitUntilFinished:YES];
    
    NSLog(@"------");
    
}

注意点：设置最大并发数对于任务数量大于1的操作是无效的

    创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    封装操作    
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"4----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"5----%@",[NSThread currentThread]);
    }];
    
   追加操作
   [op5 addExecutionBlock:^{
        NSLog(@"6----%@",[NSThread currentThread]);
    }];

   [op5 addExecutionBlock:^{
        NSLog(@"7----%@",[NSThread currentThread]);
   }];

   设置最大并发数为1
  queue.maxConcurrentOperationCount = 1;
  
  将操作添加到队列执行任务
  [queue addOperation:op4];
  [queue addOperation:op5];

  另一种添加操作到队列的方法
  [queue addOperations:@[op4,op5] waitUntilFinished:YES];

   NSLog(@"--------");

这时的执行顺序对于 op5 是无效的

注意点:
1.maxConcurrentOperationCount == 0不能执行任务。
2.默认NSOperationQueueDefaultMaxConcurrentOperationCount = -1 -1指的是一个最大的值(表示不受限制)。
3.最大并发数 不一定 等于所开的线程数：所开多少条线程是由系统决定的。
4.[queue addOperations:@[op4,op5] waitUntilFinished:YES];这是另一种添加操作到队列的方式，后面参数：YES时，必须执行完队列中的操作，才能执行之后的程序；NO时，可以不用执行完队列中的操作就可以执行程序。

队列的取消、暂停、恢复

取消队列的所有操作

-(void)cancelAllOperations;

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

暂停和恢复队列

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

- (void)start{
    //01 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //02 封装操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 5000; ++i) {
            NSLog(@"1--%zd--%@",i,[NSThread currentThread]);
        }
        
    }];
    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 5000; ++i) {
            NSLog(@"2--%zd--%@",i,[NSThread currentThread]);
        }
    }];
    
    
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 5000; ++i) {
            NSLog(@"3--%zd--%@",i,[NSThread currentThread]);
        }
    }];
    
    
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 5000; ++i) {
            NSLog(@"4--%zd--%@",i,[NSThread currentThread]);
        }
    }];
    
    //设置最大并发数
    queue.maxConcurrentOperationCount = 1;
    
    //03 添加到队列
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
    [queue addOperation:op4];
    
    self.queue = queue;
}

- (IBAction)suspendBtnClick:(id)sender {
    
    //暂停 YES
    //只能暂停当前操作后面的操作,当前操作不可分割必须执行完毕
    //操作是有状态的
    [self.queue setSuspended:YES];
}
- (IBAction)resumeBtnClick:(id)sender {
    
    //恢复
    [self.queue setSuspended:NO];
}
- (IBAction)cancelBtnClick:(id)sender {
    
    //取消 取消所有的操作
    //只能取消队列中处理等待状态的操作
    [self.queue cancelAllOperations];
}

自定义操作、自定义线程

自定义NSOperation的步骤很简单

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

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

自己创建自动释放池（因为如果是异步操作，无法访问主线程的自动释放>池）

经常通过- (BOOL)isCancelled方法检测操作是否被取消，对取消做出响应

#import "ViewController.h"
#import "KXOperation.h"
#import "KXGThread.h"

@interface ViewController ()

@property (nonatomic, strong) NSOperationQueue *queue;
@end

@implementation ViewController

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self test2];
}

-(void)thread
{
    //自定义线程
    XMGThread *thread = [[XMGThread alloc]init];
    [thread start];
}

- (IBAction)startBtnClick:(id)sender {
    
//    [self test1];
    [self test2];
    
}
- (IBAction)suspendBtnClick:(id)sender {
    
    //暂停 YES
    //只能暂停当前操作后面的操作,当前操作不可分割必须执行完毕
    //操作是有状态的
    [self.queue setSuspended:YES];
}
- (IBAction)resumeBtnClick:(id)sender {
    
    //恢复
    [self.queue setSuspended:NO];
}
- (IBAction)cancelBtnClick:(id)sender {
    
    //取消 取消所有的操作
    //只能取消队列中处理等待状态的操作
    [self.queue cancelAllOperations];
}

-(void)test2
{
    //01 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    //02 封装操作(执行任务)
    XMGOperation *op = [[XMGOperation alloc]init];
    
    //03 把操作添加到队列
    [queue addOperation:op];   //内部会调用start方法 ->main
    
    //自定义操作的好处:代码复用
    self.queue = queue;
}
@end

-------------------------------------------------------------------
#import "KXGOperation.h"

@implementation KXGOperation

//重写内部的main方法类告诉自定义的操作任务是什么?
-(void)main
{
    // NSLog(@"main----%@",[NSThread currentThread]);
    for (int i = 0; i < 10000; ++i) {
        NSLog(@"1---%zd--%@",i,[NSThread currentThread]);
    }
    
    //官方建议:在自定义操作的时候每执行完一个耗时操作就判断一下当前操作是否被取消,如果被取消就直接返回
    if (self.isCancelled) {
        return;
    }
    
    NSLog(@"++++++++++++++++");
    
    for (int i = 0; i < 10000; ++i) {
        NSLog(@"2---%zd--%@",i,[NSThread currentThread]);
    }
    
    if (self.isCancelled) {
        return;
    }
     NSLog(@"++++++++++++++++");
    
    for (int i = 0; i < 10000; ++i) {
        NSLog(@"3d---%zd--%@",i,[NSThread currentThread]);
    }
    
}
@end

-------------------------------------------------------------------
#import "KXGThread.h"

@implementation KXGThread

-(void)main
{
    NSLog(@"MAIN----%@",[NSThread currentThread]);
}
@end

操作依赖

NSOperation之间可以设置依赖来保证执行顺序

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

可以在不同queue的NSOperation之间创建依赖关系。 operation.png

注意：不能相互依赖
比如:A依赖B，B依赖A

操作的监听

可以监听一个操作的执行完毕
-(void (^)(void))completionBlock;
-(void)setCompletionBlock:(void (^)(void))block;

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    //01 创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    NSOperationQueue *queue2 = [[NSOperationQueue alloc]init];
    
    //02 封装操作对象
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"3----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op4 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"4----%@",[NSThread currentThread]);
    }];
    
    NSBlockOperation *op5 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"5----%@",[NSThread currentThread]);
    }];
    
    //监听任务执行完毕
    op4.completionBlock = ^{
        
        NSLog(@"小4任务已完成");
    };
    
    [op1 setCompletionBlock:^{
         NSLog(@"老幺任务已完成");
    }];
    
    //03 设置操作依赖:4->3->2->1->5
    //⚠️ 不能设置循环依赖,结果就是两个任务都不会执行
    [op5 addDependency:op1];
    [op1 addDependency:op2];
    //[op2 addDependency:op1];
    [op2 addDependency:op3];
    [op3 addDependency:op4];
    
    //04 把操作添加到队列
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
    [queue addOperation:op4];
    [queue2 addOperation:op5];
    
    
}

线程间的通信

01 创建队列
NSOperationQueue *queue  =[[NSOperationQueue alloc]init];

02封装操作
NSBlockOperation *download = [NSBlockOperation blockOperationWithBlock:^{

            执行任务
       [[NSOperationQueue mainQueue] addOperationWithBlock:^{

              回到主线程           

       }];

 }];

03 把操作添加到队列
[queue addOperation:download];

GCD和NSOperation的对比：

1）GCD是纯C语言的API,而操作队列则是Object-C的对象。
2）在GCD中，任务用块（block）来表示，而块是个轻量级的数据结构；
   相反操作队列中的『操作』NSOperation则是个更加重量级的Object-C对象。
3）具体该使用GCD还是使用NSOperation需要看具体的情况

 
NSOperation和NSOperationQueue的好处有：
1）NSOperationQueue可以方便的调用cancel方法来取消某个操作，而GCD中的任务是无法被取消的（安排好任务之后就不管了）。
2）NSOperation可以方便的指定操作间的依赖关系。
3）NSOperation可以通过KVO提供对NSOperation对象的精细控制（如监听当前操作是否被取消或是否已经完成等）
4）NSOperation可以方便的指定操作优先级。操作优先级表示此操作与队列中其它操作之间的优先关系，优先级高的操作先执行，优先级低的后执行。
5）通过自定义NSOperation的子类可以实现操作重用.

使用Crearte函数创建的并发队列和全局并发队列的主要区别：

1）全局并发队列在整个应用程序中本身是默认存在的并且对应有高优先级、默认优先级、低优先级和后台优先级一共四个并发队列，我们只是选择其中的一个直接拿来用。而Create函数是实打实的从头开始去创建一个队列。
 
2）在iOS6.0之前，在GCD中凡是使用了带Create和retain的函数在最后都需要做一次release操作。而主队列和全局并发队列不需要我们手动release。当然了，在iOS6.0之后GCD已经被纳入到了ARC的内存管理范畴中，即便是使用retain或者create函数创建的对象也不再需要开发人员手动释放，我们像对待普通OC对象一样对待GCD就OK。
 
3）在使用栅栏函数的时候，苹果官方明确规定栅栏函数只有在和使用create函数自己的创建的并发队列一起使用的时候才有效（没有给出具体原因）
4）其它区别涉及到XNU内核的系统级线程编程，不一一列举。

多线程相关知识希望给朋友们带来一丢丢的帮助,如有问题敬请批正！！！

iOS开发之多线程：Pthread、NSThread、GCD、N

进程

什么是进程？

通过“活动监视器”可以查看Mac系统中所开启的进程

线程

什么是线程？

线程的串行

进程和线程的比较

多线程

基本概念

线程的并行：

多线程并发执行的原理：

多线程的优缺点：

多线程在iOS开发中的应用

主线程：

主线程的主要作用：

`主线程的使用注意！`

耗时操作的执行

问题在哪？

iOS开发中多线程的实线方案

pthread

NSThread

GCD

任务和队列

执行任务

GCD的线程之间的通信

GCD的其他函数：

GCD的队列组：

NSOperation 与 NSOperationQueue

自定义操作、自定义线程

操作依赖

操作的监听

线程间的通信

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

IOS线程

iOS开发之多线程：Pthread、NSThread、GCD、N

进程

什么是进程？

通过“活动监视器”可以查看Mac系统中所开启的进程

线程

什么是线程？

线程的串行

进程和线程的比较

多线程

基本概念

线程的并行：

多线程并发执行的原理：

多线程的优缺点：

多线程在iOS开发中的应用

主线程：

主线程的主要作用：

主线程的使用注意 ！

耗时操作的执行

问题在哪？

iOS开发中 多线程 的实线方案

pthread

NSThread

GCD

任务和队列

执行任务

GCD的线程之间的通信

GCD的其他函数：

GCD的队列组：

NSOperation 与 NSOperationQueue

自定义操作、自定义线程

操作依赖

操作的监听

线程间的通信

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

IOS线程

`主线程的使用注意！`

iOS开发中多线程的实线方案