相关代码：
https://pan.baidu.com/s/1nvNdedz
https://pan.baidu.com/s/1qYF5vRI
请配合代码阅读，文章内容来源于小马哥视频

Tips: 作者会不定期更新类似总结性的文章，如果你喜欢，请关注我。

多线程中的基本概念

1. 进程

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

2. 线程

基本概念
1个进程要想执行任务，必须得有线程（每1个进程至少要有1条线程），线程是进程的基本执行单元，一个进程（程序）的所有任务都在线程中执行。
- 线程的串行
1个线程中任务的执行是串行的，如果要在1个线程中执行多个任务，那么只能一个一个地按顺序执行这些任务。也就是说，在同一时间内，1个线程只能执行1个任务。

3. 多线程

基本概念
- 即1个进程中可以开启多条线程，每条线程可以并行（同时）执行不同的任务。
线程的并行
- 并行即同时执行。比如同时开启3条线程分别下载3个文件（分别是文件A、文件B、文件C）。
多线程并发执行的原理
- 在同一时间里，CPU只能处理1条线程，只有1条线程在工作（执行）。多线程并发（同时）执行，其实是CPU快速地在多条线程之间调度（切换），如果CPU调度线程的时间足够快，就造成了多线程并发执行的假象。
多线程优缺点
- 优点
  - 能适当提高程序的执行效率。
  - 能适当提高资源利用率（CPU、内存利用率）
- 缺点
  - 开启线程需要占用一定的内存空间（默认情况下，主线程占用1M，子线程占用512KB），如果开启大量的线程，会占用大量的内存空间，降低程序的性能。
  - 线程越多，CPU在调度线程上的开销就越大。
  - 程序设计更加复杂：比如线程之间的通信、多线程的数据共享

4. 多线程在iOS开发中的应用

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

5. iOS中多线程的实现方案

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

pthread`［了解，主要是为了能看得懂三方库的代码］`

#import 
   
//使用pthread创建线程对象 
pthread_t thread;
NSString *name = @"wendingding"; 

//使用pthread创建线程 

//第一个参数：线程对象地址
//第二个参数：线程属性
//第三个参数：指向函数的指针 
//第四个参数：传递给该函数的参数 
pthread_create(&thread, NULL, run, (__bridge void *)(name));

NSThread

1. 基本用法

/*
  第一种创建线程的方式：alloc init.
  特点：需要手动开启线程，可以拿到线程对象进行详细设置 
  
  创建线程 
  第一个参数：目标对象 
  第二个参数：选择器，线程启动要调用哪个方法 
  第三个参数：前面方法要接收的参数（最多只能接收一个参数，没有则传nil）
 **/
 
NSThread *thread = [[NSThread alloc]initWithTarget:self selector:@selector(run:) object:@"wendingding"]; 

//设置属性
threadA.name = @"线程A";
//设置优先级  取值范围 0.0 ~ 1.0 之间 最高是1.0 默认优先级是0.5 优先级越高，执行的次数（可能性）越高
threadA.threadPriority = 1.0;
/**
启动线程
!!![线程处于就绪状态，所有被标记为start的线程会被维护在一个池中，
这样系统就会知道这个池中的所有线程都是需要被调用的。
然后CPU快速地在多条线程之间调度（切换），造成了多线程并发执行的假象。]
*/
[thread start];

/*
  第二种创建线程的方式：分离出一条子线程
  特点：自动启动线程，无法对线程进行更详细的设置 

  第一个参数：线程启动调用的方法
  第二个参数：目标对象
  第三个参数：传递给调用方法的参数 
**/
 
[NSThread detachNewThreadSelector:@selector(run:) toTarget:self withObject:@"我是分离出来的子线程"];

/*
  第三种创建线程的方式：后台线程
  !!!这是NSObject的类别方法，所有只要是NSObject的子类，都可以调用此方法！
  特点：自动启动线程，无法进行更详细设置
**/

[self performSelectorInBackground:@selector(run:) withObject:@"我是后台线程"];

2. 线程的状态`[了解］`

//线程的各种状态：新建-就绪-运行-阻塞-死亡

//常用的控制线程状态的方法
[NSThread exit];
//退出当前线程
[NSThread sleepForTimeInterval:2.0];
//阻塞线程
[NSThread sleepUntilDate:[NSDate dateWithTimeIntervalSinceNow:2.0]];
//阻塞线程

//注意：线程死了不能复生

3. 线程安全

前提：多个线程访问同一块资源会发生数据安全问题
解决方案：加互斥锁
相关代码：@synchronized(self){}


-(void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    
    //设置中票数
    self.totalCount = 100;
    
     self.threadA = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicket) object:nil];
     self.threadB = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicket) object:nil];
     self.threadC = [[NSThread alloc]initWithTarget:self selector:@selector(saleTicket) object:nil];
    
    self.threadA.name = @"售票员A";
    self.threadB.name = @"售票员B";
    self.threadC.name = @"售票员C";
    
    //启动线程
    @synchronized(self) {
        [self.threadA start];
        [self.threadB start];
        [self.threadC start];
    }
    
}

- (void) saleTicket{
    while (1) {
        
    //锁:必须是全局唯一的
    //1.注意枷锁的位置
    //2.注意枷锁的前提条件,多线程共享同一块资源
    //3.注意加锁是需要代价的,需要耗费性能的
    //4.加锁的结果:线程同步
        
    @synchronized(self) {
        //线程1
        //线程2
        //线程3
        NSInteger count = self.totalCount;
        if (count >0) {
            
            for (NSInteger i = 0; i<1000000; i++) {
            }
            
            self.totalCount = count - 1;
            //卖出去一张票
            NSLog(@"%@卖出去了一张票,还剩下%zd张票", [NSThread currentThread].name,self.totalCount);
        }else
        {
            NSLog(@"不要回公司上班了");
            break;
        }
        }
    } 
}

专业术语-线程同步
原子和非原子属性
nonatomic 非原子性即未在set方法中自动添加锁，可能存在多个线程对其修改时错误。
atomic 原子性在set方法中自动添加锁

4. 线程间通信`［即子线程做事，主线程刷新UI］`

- (void)touchesBegan:(nonnull NSSet *)touches withEvent:(nullable UIEvent *)event{
  //开启一条子线程来下载图片 
  [NSThread detachNewThreadSelector:@selector(downloadImage) toTarget:self withObject:nil];
}

- (void)downloadImage{ 
  //1.确定要下载网络图片的url地址，一个url唯一对应着网络上的一个资源 
  NSURL *url = [NSURL URLWithString:@"http://p6.qhimg.com/t01d2954e2799c461ab.jpg"]; 

  //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];
}

附送：计算代码段执行时间


//计算代码段执行时间的第一种方法
-(void)download1
{
    //0.000018
    //0.166099
    
    //1.确定URL
    NSURL *url = [NSURL URLWithString:@"http://img4.duitang.com/uploads/blog/201310/18/20131018213446_smUw4.thumb.700_0.jpeg"];

    NSDate *start = [NSDate date];  //获得当前的时间
    
    //2.根据url下载图片二进制数据到本地
    NSData *imageData = [NSData dataWithContentsOfURL:url];
    
    NSDate *end = [NSDate date];  //获得当前的时间
    NSLog(@"%f",[end timeIntervalSinceDate:start]);
    
    //3.转换图片格式
    UIImage *image = [UIImage imageWithData:imageData];
    
    //4.显示UI
    self.imageView.image = image;
}

//计算代码段执行时间的第二种方法
-(void)download2
{
    //1.确定URL
    NSURL *url = [NSURL URLWithString:@"http://img4.duitang.com/uploads/blog/201310/18/20131018213446_smUw4.thumb.700_0.jpeg"];
    
    CFTimeInterval start = CFAbsoluteTimeGetCurrent();
    
    //2.根据url下载图片二进制数据到本地
    NSData *imageData = [NSData dataWithContentsOfURL:url];
    
    CFTimeInterval end = CFAbsoluteTimeGetCurrent();
    NSLog(@"end-start = %f---%f---%f",end - start,end,start);
    
    //3.转换图片格式
    UIImage *image = [UIImage imageWithData:imageData];
    
    //4.显示UI
    self.imageView.image = image;
}

GCD

1. 队列和任务

-(void)asyncConcurrent
{
    //1.1自己创建一个队列
    /*
     第一个参数:C语言的字符串,标签
     第二个参数:队列的类型
        DISPATCH_QUEUE_CONCURRENT:并发
        DISPATCH_QUEUE_SERIAL:串行
     */
    //dispatch_queue_t queue = dispatch_queue_create("com.520it.download", DISPATCH_QUEUE_CONCURRENT);
    
    //1.2获得全局并发队列
    /*
     第一个参数:优先级
     第二个参数:
     */
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    NSLog(@"---satrt----");
    
    //2.1>封装任务2>添加任务到队列中
    /*
     第一个参数:队列
     第二个参数:要执行的任务
     */
    dispatch_async(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
    
     NSLog(@"---end----");
}

2. GCD基本使用`[不需要死记，理解即可。注意死锁的情况]`

* 异步函数+并发队列：开启多条线程，并发执行任务
* 异步函数+串行队列：开启一条线程，串行执行任务
* 同步函数+并发队列：不开线程，串行执行任务
* 同步函数+串行队列：不开线程，串行执行任务
* 异步函数+主队列：不开线程，在主线程中串行执行任务
* 同步函数+主队列：不开线程，串行执行任务（注意死锁发生）

注意同步函数和异步函数在执行顺序上面的差异

//异步函数+并发队列:会开启多条线程,队列中的任务是并发执行
-(void)asyncConcurrent
{
    //1.创建队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    //2.封装任务
    dispatch_async(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
    
     NSLog(@"---end----");
}

//异步函数+串行队列:会开一条线程,队列中的任务是串行执行的
-(void)asyncSerial
{
    //1.创建队列
    dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_SERIAL);

    //2.封装操作
    dispatch_async(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
}

//同步函数+并发队列:不会开线程,任务是串行执行的
-(void)syncConcurrent
{
    //1.创建队列
    dispatch_queue_t queue = dispatch_queue_create("com.520it.download", DISPATCH_QUEUE_CONCURRENT);
    
    NSLog(@"---start---");
    //2.封装任务
    dispatch_sync(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
    
     NSLog(@"---end---");
}

//同步函数+串行队列:不会开线程,任务是串行执行的
-(void)syncSerial
{
    //1.创建队列
    dispatch_queue_t queue = dispatch_queue_create("com.520it.download", DISPATCH_QUEUE_SERIAL);
    
    //2.封装任务
    dispatch_sync(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
}

//异步函数+主队列:所有任务都在主线程中执行,不会开线程
-(void)asyncMain
{
    //1.获得主队列
    dispatch_queue_t queue = dispatch_get_main_queue();

    //2.异步函数
    dispatch_async(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
}

//同步函数+主队列:死锁
//注意:如果该方法在子线程中执行,那么所有的任务在主线程中执行,
-(void)syncMain
{
    //1.获得主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    NSLog(@"start----");
    //2.同步函数
    //同步函数:立刻马上执行,如果我没有执行完毕,那么后面的也别想执行
    //异步函数:如果我没有执行完毕,那么后面的也可以执行
    dispatch_sync(queue, ^{
        NSLog(@"download1----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download2----%@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"download3----%@",[NSThread currentThread]);
    });
    
    NSLog(@"end---");
}

3. GCD线程间通信`［子线程操作，主线程刷新UI］`

  //0.获取一个全局的队列 
  dispatch_queue_t queue = dispatch_get_global_queue(0, 0); 

  //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]); 
    });
  });

4. GCD其他常用函数

栅栏函数（控制任务的执行顺序）

    //0.获得全局并发队列
    //栅栏函数不能使用全局并发队列
    //dispatch_queue_t queue =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_queue_t queue = dispatch_queue_create("download", DISPATCH_QUEUE_CONCURRENT);
    
    //1.异步函数
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<100; i++) {
            NSLog(@"download1-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    dispatch_async(queue, ^{  
        for (NSInteger i = 0; i<100; i++) {
            NSLog(@"download2-%zd-%@",i,[NSThread currentThread]);
        }
    });
     
    //栅栏函数
    dispatch_barrier_async(queue, ^{
        NSLog(@"+++++++++++++++++++++++++++++");
    });
    
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<100; i++) {
            NSLog(@"download3-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    dispatch_async(queue, ^{
        for (NSInteger i = 0; i<100; i++) {
            NSLog(@"download4-%zd-%@",i,[NSThread currentThread]);
        }
    });

执行结果是先打印download1和download2 [前后顺序不一定]，然后打印+++，最后再打印download3和download4 [前后顺序不一定]

延迟执行[一定时间后，将执行的操作加入到队列中]

//1.第一种用法    
/* 
   NSEC_PER_SEC 秒     
   NSEC_PER_MSEC 毫秒    
   NSEC_PER_USEC 微秒     
*/    

/*
   DISPATCH_TIME_NOW  从现在开始
   DISPATCH_TIME_FOREVER 从此刻到永远
*/

//5秒之后
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC));       

//5秒后在主线程执行
dispatch_after(time, dispatch_get_main_queue(), ^{        
//执行操作       
 NSLog(@"after 5s");    
});

!!!!!需要注意的是，使用dispatch_after实现延迟执行某动作，时间并不是很精确，实际上是过多久将Block追加到main Queue中，而不是执行该动作，理论上是：主线程 RunLoop 1/60秒检测时间，追加的时间范围 5s~(5+1/60)s
如果此时main queue中的任务很多，没有执行完毕，那么新添加的这个动作就要继续推迟。如果对时间的精确度没有高要求，只是为了推迟执行，那么使用dispatch_after还是很不错的。

//2.第二种用法  
//执行的c语言方法    
dispatch_after_f(dispatch_time(DISPATCH_TIME_NOW, 3ull *NSEC_PER_SEC), dispatch_get_main_queue(), NULL, fun1);

//c函数
void fun1(){   
 NSLog(@"after 3s");
}

//3.第三种用法    
//其实和第一种方法是一样的，只是参数已经帮我们填写好了，我们只需要填写时间和执行block
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ 
        NSLog(@"after 5s");   
 });

只执行一次的代码［单例模式］

static XMGTool *_instance;

//本身就是线程安全的
static dispatch_once_t onceToken;

dispatch_once(&onceToken, ^{
    _instance = [super allocWithZone:zone];
});
    
return _instance;

快速迭代（开多个线程并发完成迭代操作）

//一般的遍历操作，我们放在一个for循环中执行
- (void)forDemo{
    //同步
    for (NSInteger i = 0; i<10; i++) {
        NSLog(@"%zd---%@",i,[NSThread currentThread]);
    }
}

//但是如果遍历的操作需要更快的执行完，我们就可以使用dispatch_apply
//开子线程和主线程一起完成遍历任务,任务的执行时并发的。
-(void)applyDemo{
     /*
     第一个参数:遍历的次数
     第二个参数:队列(并发队列)
     第三个参数:index 索引
     */
    dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index) {
        NSLog(@"%zd---%@",index,[NSThread currentThread]);
    });
}

接下来我们拿一个移动文件的例子来说明遍历的作用：

//使用for循环
-(void)moveFile
{
    //1.拿到文件路径
    NSString *from = @"/Users/xiaomage/Desktop/from";
    
    //2.获得目标文件路径
    NSString *to = @"/Users/xiaomage/Desktop/to";
    
    //3.得到目录下面的所有文件
    NSArray *subPaths = [[NSFileManager defaultManager] subpathsAtPath:from];
    
    //4.遍历所有文件,然后执行剪切操作
    NSInteger count = subPaths.count;
    
    for (NSInteger i = 0; i< count; i++) {
        
        //4.1 拼接文件的全路径
       // NSString *fullPath = [from stringByAppendingString:subPaths[i]];
        NSString *fullPath = [from stringByAppendingPathComponent:subPaths[i]];
        NSString *toFullPath = [to stringByAppendingPathComponent:subPaths[i]];
        
        NSLog(@"%@",fullPath);
        //4.2 执行剪切操作
        /*
         第一个参数:要剪切的文件在哪里
         第二个参数:文件应该被存到哪个位置
         */
        [[NSFileManager defaultManager]moveItemAtPath:fullPath toPath:toFullPath error:nil];
        
        NSLog(@"%@---%@--%@",fullPath,toFullPath,[NSThread currentThread]);
    }
}

-(void)moveFileWithGCD
{
    //1.拿到文件路径
    NSString *from = @"/Users/xiaomage/Desktop/from";
    
    //2.获得目标文件路径
    NSString *to = @"/Users/xiaomage/Desktop/to";
    
    //3.得到目录下面的所有文件
    NSArray *subPaths = [[NSFileManager defaultManager] subpathsAtPath:from];
    
    NSLog(@"%@",subPaths);
    //4.遍历所有文件,然后执行剪切操作
    NSInteger count = subPaths.count;
    
    dispatch_apply(count, dispatch_get_global_queue(0, 0), ^(size_t i) {
        //4.1 拼接文件的全路径
        // NSString *fullPath = [from stringByAppendingString:subPaths[i]];
        //在拼接的时候会自动添加/
        NSString *fullPath = [from stringByAppendingPathComponent:subPaths[i]];
        NSString *toFullPath = [to stringByAppendingPathComponent:subPaths[i]];
        
        NSLog(@"%@",fullPath);
        //4.2 执行剪切操作
        /*
         第一个参数:要剪切的文件在哪里
         第二个参数:文件应该被存到哪个位置
         */
        [[NSFileManager defaultManager]moveItemAtPath:fullPath toPath:toFullPath error:nil];
     
        NSLog(@"%@---%@--%@",fullPath,toFullPath,[NSThread currentThread]);
    });
}

需要注意的是，并不是count为多少就开启多少个线程，系统会自己判断需要开启多少个线程来完成此次遍历。换句话说，如果遍历时已经开启了两条异步线程，这时第三条数据需要异步操作，系统会判断之前的线程有没有空闲的，如果有空闲的线程，那么不会创建新的线程，而是用空闲线程来完成任务。

队列组

如果某个界面上有两个接口请求，我们需要在两个接口都返回的情况下刷新UI，那么我们可以使用队列组来实现。


//1.创建队列
dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    
//2.创建队列组
dispatch_group_t group = dispatch_group_create();
    
//3.异步函数
 /*
     1)封装任务
     2)把任务添加到队列中
     3)dispatch_group_notify会监听任务的执行情况,通知group
*/
    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_notify(group, queue, ^{        
        NSLog(@"-------dispatch_group_notify-------");
    });

之前我们创建一个异步线程操作是使用方法dispatch_async，而这里是使用dispatch_group_async

第二种实现方法：

//1.创建队列
dispatch_queue_t queue =dispatch_get_global_queue(0, 0);
    
//2.创建队列组
dispatch_group_t group = dispatch_group_create();
    
//3.在该方法后面的异步任务会被纳入到队列组的监听范围,进入群组
//dispatch_group_enter|dispatch_group_leave 必须要配对使用
    
dispatch_group_enter(group);
    
dispatch_async(queue, ^{
  NSLog(@"1----%@",[NSThread currentThread]);
  
  //离开群组
  dispatch_group_leave(group);
});
    
dispatch_group_enter(group);
    
dispatch_async(queue, ^{
  NSLog(@"2----%@",[NSThread currentThread]);
    
  //离开群组
  dispatch_group_leave(group);
});
    
    
//拦截通知
//问题?该方法是阻塞的吗?  内部本身是异步的,所以不会
//    dispatch_group_notify(group, queue, ^{
//        NSLog(@"-------dispatch_group_notify-------");
//    });
    
//等待.死等. 直到队列组中所有的任务都执行完毕之后才能执行
//阻塞的
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"----end----");

NSOperation

相关概念
- NSOperation是对GCD的包装
- 两个核心概念[队列]＋[操作]
基本使用
- NSOperation本身是抽象类，我们使用的是他的子类
- 三个子类分别是:NSBlockOperation, NSInvocationOperation以及自定义继承自NSOperation的类
- NSOperation单独使用无法实现多线程，需要和NSOperationQueue结合使用才能实现。
相关代码

//  01 NSInvocationOperation
    //1.封装操作
    /*
     第一个参数：目标对象
     第二个参数：该操作要调用的方法，最多接受一个参数
     第三个参数：调用方法传递的参数，如果方法不接受参数，那么该值传nil
     */
    //必须添加队列才会生成新线程

    NSInvocationOperation *operation = [[NSInvocationOperation alloc]
                                        initWithTarget:self selector:@selector(run) object:nil];

    //2.启动操作
    [operation start];
-------------------------------------------------
    //  02 NSBlockOperation
    //1.封装操作
    /*
     NSBlockOperation提供了一个类方法，在该类方法中封装操作
     */
    NSBlockOperation *operation = [NSBlockOperation blockOperationWithBlock:^{
        //在主线程中执行
        NSLog(@"---download1--%@",[NSThread currentThread]);
    }];

    //2.追加操作，追加的操作在子线程中执行

    //追加任务
    //注意:如果一个操作中的任务数量大于1,那么会开子线程并发执行任务
    //注意:不一定是子线程,有可能是主线程
    [operation addExecutionBlock:^{
        NSLog(@"---download2--%@",[NSThread currentThread]);
    }];

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

    //3.启动执行操作
    [operation start];

----------------------------------------------
// 03 自定义NSOperation
    //如何封装操作？
    //自定义的NSOperation,通过重写内部的main方法实现封装操作
    -(void)main
    {
        NSLog(@"--main--%@",[NSThread currentThread]);
    }

    //如何使用？
    //1.实例化一个自定义操作对象
    XMGOperation *op = [[XMGOperation alloc]init];

    //2.执行操作
    [op start];

NSOperationQueue基本使用
- NSOperationQueue中的两种队列
  - 主队列通过mainQueue获得，凡是放到主队列中的任务都是将在主线程执行
  - 非主队列直接alloc init出来的队列。非主队列同时具备了并发和串行的功能，通过设置最大并发数属性来控制任务是并发任务还是串行任务。
相关代码

//自定义NSOperation
-(void)customOperation
{
    //1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    //2.封装操作
    //好处：1.信息隐蔽
    //2.代码复用

    XMGOperation *op1 = [[XMGOperation alloc]init];
    XMGOperation *op2 = [[XMGOperation alloc]init];

    //3.添加操作到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];
}

//NSBlockOperation
- (void)block
{
    //1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    //2.封装操作
    NSBlockOperation *op1 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"1----%@",[NSThread currentThread]);
    }];

    NSBlockOperation *op2 = [NSBlockOperation blockOperationWithBlock:^{
        NSLog(@"2----%@",[NSThread currentThread]);

    }];

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

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

    //3.添加操作到队列中
    [queue addOperation:op1];
    [queue addOperation:op2];

    //补充：简便方法
    [queue addOperationWithBlock:^{
        NSLog(@"5----%@",[NSThread currentThread]);
    }];

}

//NSInvocationOperation
- (void)invocation
{
    /*
     GCD中的队列：
     串行队列：自己创建的，主队列
     并发队列：自己创建的，全局并发队列

     NSOperationQueue
     主队列：[NSOperationQueue mainqueue];凡事放在主队列中的操作都在主线程中执行
     非主队列：[[NSOperationQueue alloc]init]，并发和串行，默认是并发执行的
     */

    //1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];

    //2.封装操作
    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];

    //3.把封装好的操作添加到队列中
    //不需要手动调用[op1 start]
    [queue addOperation:op1];
    [queue addOperation:op2];
    [queue addOperation:op3];
}

NSOperation其他用法
- 设置最大并发数［控制任务并发和串行］

//1.创建队列
NSOperationQueue *queue = [[NSOperationQueue alloc]init];

//2.设置最大并发数量 maxConcurrentOperationCount

//同一时间最多有多少个任务可以执行(实际开起的线程总数大于maxConcurrentOperationCount)
//串行执行任务!=只开一条线程 (线程同步)
// maxConcurrentOperationCount >1 那么就是并发队列
// maxConcurrentOperationCount == 1 那就是串行队列
// maxConcurrentOperationCount == 0  不会执行任务
// maxConcurrentOperationCount == -1 特殊意义 最大值 表示不受限制
queue.maxConcurrentOperationCount = 2;

暂停和恢复以及取消

//设置暂停和恢复
//suspended设置为YES表示暂停，suspended设置为NO表示恢复
//暂停表示不继续执行队列中的下一个任务，暂停操作是可以恢复的
if (self.queue.isSuspended) {
      self.queue.suspended = NO;
}else
{
      self.queue.suspended = YES;
}

//取消队列里面的所有操作
//取消之后，当前正在执行的操作的下一个操作将不再执行，而且永远都不在执行，就像后面的所有任务都从队列里面移除了一样
//取消操作是不可以恢复的
[self.queue cancelAllOperations];

---------自定义NSOperation取消操作--------------------------
//自定义NSOperation子类需要重写main方法，用于执行线程中的操作
-(void)main
{
    //耗时操作1
    for (int i = 0; i<1000; i++) {
        NSLog(@"任务1-%d--%@",i,[NSThread currentThread]);
    }
    NSLog(@"+++++++++++++++++++++++++++++++++");

    //苹果官方建议，每当执行完一次耗时操作之后，就查看一下当前队列是否为取消状态，如果是，那么就直接退出
    //好处是可以提高程序的性能
    if (self.isCancelled) {
        return;
    }

    //耗时操作2
    for (int i = 0; i<1000; i++) {
        NSLog(@"任务1-%d--%@",i,[NSThread currentThread]);
    }

    NSLog(@"+++++++++++++++++++++++++++++++++");
}

下载多张图片合成综合案例（设置操作依赖）

/*
 1.下载图片1
 2.下载图片2
 3.合并图片
 */
-(void)comBie
{
    //1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc]init];
    
    __block UIImage *image1;
    __block UIImage *image2;
    //2 封装操作,下载图片1
    NSBlockOperation *download1 = [NSBlockOperation blockOperationWithBlock:^{
        
        NSURL *url = [NSURL URLWithString:@"http://s15.sinaimg.cn/bmiddle/4c0b78455061c1b7f1d0e"];
        NSData *imageData = [NSData dataWithContentsOfURL:url];
        image1 = [UIImage imageWithData:imageData];
        
        NSLog(@"download---%@",[NSThread currentThread]);
        
    }];
    
    //3 封装操作,下载图片2
    NSBlockOperation *download2 = [NSBlockOperation blockOperationWithBlock:^{
        
        NSURL *url = [NSURL URLWithString:@"http://www.027art.com/feizhuliu/UploadFiles_6650/201109/2011091718442835.jpg"];
        NSData *imageData = [NSData dataWithContentsOfURL:url];
        image2 = [UIImage imageWithData:imageData];
        
        NSLog(@"download---%@",[NSThread currentThread]);
        
    }];
    
    //4.封装合并图片的操作
    NSBlockOperation *combie = [NSBlockOperation blockOperationWithBlock:^{
        //4.1 开上下文
        UIGraphicsBeginImageContext(CGSizeMake(200, 200));
        
        //4.2 画图1
        [image1 drawInRect:CGRectMake(0, 0, 100, 200)];
        
        //4.3 画图2
        [image2 drawInRect:CGRectMake(100, 0, 100, 200)];
        
        //4.4 根据上下文得到图片
        UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
        
        //4.5 关闭上下文
        UIGraphicsEndImageContext();
        
        //7.更新UI
        [[NSOperationQueue mainQueue] addOperationWithBlock:^{
            self.imageView.image = image;
            NSLog(@"UI----%@",[NSThread currentThread]);
        }];
        
    }];
    
    //5.设置依赖关系
    //依赖的作用是：线程会在依赖执行完成后，再执行
    [combie addDependency:download1];
    [combie addDependency:download2];
    
    //6.添加操作到队列中
    [queue addOperation:download2];
    [queue addOperation:download1];
    [queue addOperation:combie];
}

填坑...

没错！多线程全部在这里了！

多线程中的基本概念

1. 进程

2. 线程

3. 多线程

4. 多线程在iOS开发中的应用

5. iOS中多线程的实现方案

pthread`［了解，主要是为了能看得懂三方库的代码］`

NSThread

1. 基本用法

2. 线程的状态`[了解］`

3. 线程安全

4. 线程间通信`［即子线程做事，主线程刷新UI］`

GCD

1. 队列和任务

2. GCD基本使用`[不需要死记，理解即可。注意死锁的情况]`

3. GCD线程间通信`［子线程操作，主线程刷新UI］`

4. GCD其他常用函数

NSOperation

你可能感兴趣的:(没错！多线程全部在这里了！)

没错！多线程全部在这里了！

多线程中的基本概念

1. 进程

2. 线程

3. 多线程

4. 多线程在iOS开发中的应用

5. iOS中多线程的实现方案

pthread［了解，主要是为了能看得懂三方库的代码］

NSThread

1. 基本用法

2. 线程的状态[了解］

3. 线程安全

4. 线程间通信［即子线程做事，主线程刷新UI］

GCD

1. 队列和任务

2. GCD基本使用[不需要死记，理解即可。注意死锁的情况]

3. GCD线程间通信［子线程操作，主线程刷新UI］

4. GCD其他常用函数

NSOperation

你可能感兴趣的:(没错！多线程全部在这里了！)

pthread`［了解，主要是为了能看得懂三方库的代码］`

2. 线程的状态`[了解］`

4. 线程间通信`［即子线程做事，主线程刷新UI］`

2. GCD基本使用`[不需要死记，理解即可。注意死锁的情况]`

3. GCD线程间通信`［子线程操作，主线程刷新UI］`