×

iOS多线程(手把手教你进阶)

96
IIronMan
2016.11.03 16:41* 字数 5466

.一.进程

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

  • 比如同时打开迅雷、Xcode,系统就会分别启动2个进程

二.线程

  • 1.什么是线程?
    答:1个进程要想执行任务,必须得有线程(每1个进程至少要有1条线程),一个进程(程序)的所有任务都在线程中执行

  • 比如使用酷狗播放音乐、使用迅雷下载电影,都需要在线程中执行

  • 2.线程的串行

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

  • <2>.比如在1个线程中下载3个文件(分别是文件A、文件B、文件C)

  • 3.多线程

  • <1>什么是多线程?
    答:1个进程中可以开启多条线程,每条线程可以并行(同时)执行不同的任务,多线程技术可以提高程序的执行效率.

  • 比如下载文件:可以同时下载

  • <2>.多线程的原理

    多线程的原理
    (1).同一时间,CPU只能处理1条线程,只有1条线程在工作(执行)
    (2).多线程并发(同时)执行,其实是CPU快速地在多条线程之间调度(切换)
    (3).如果CPU调度线程的时间足够快,就造成了多线程并发执行的假象
    
  • 问题:如果线程非常非常多,会发生什么情况?

答:1.CPU会在N多线程之间调度,CPU会累死,消耗大量的CPU资源,2.每条线程被调度执行的频次会降低(线程的执行效率降低)

  • <3>.多线程的优缺点

    多线程的优点:1.能适当提高程序的执行效率,2.能适当提高资源利用率(CPU、内存利用率)

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

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

  • (1).主线程

  • 1.什么是主线程?
    答:一个iOS程序运行后,默认会开启1条线程,称为“主线程”或“UI线程”

  • 2.主线程的主要作用

    • 显示\刷新UI界面
    • 处理UI事件(比如点击事件、滚动事件、拖拽事件等)
  • 3.主线程的使用注意

    • 别将比较耗时的操作放到主线程中
    • 耗时操作会卡住主线程,严重影响UI的流畅度,给用户一种“卡”的坏体验
  • 4.如果将耗时操作放在主线程:主线程的的UI无法更新,按钮不可用,必须等耗时操作完成才有反应

耗时操作放在主线程

耗时操作demo 密码: qugm

  • 5.如果将耗时操作放在子线程(后台线程、非主线程)

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

iOS中多线程的实现方案

五.对多线程开辟的详细介绍

  • 1.pthread的详细介绍

    • 1.导入: #import <pthread.h>

    • 2.开辟子线程(调用的是一个函数)

      pthread_t thread;
      pthread_create(&thread, NULL, run, NULL);
      
    • 3.调用子线程

       void *run(void *param)
      {
              for (NSInteger i = 0; i<50000; i++)
             {
               NSLog(@"-----buttonClick-----%zd",i);
             }
             return NULL;
       }
      

      pthread代码 密码: 18xb

  • 2.NSThread

  • (1).一个NSThread对象就代表一条线程(这种创建方式可以拿到线程的对象以及可以对线程设置名字,以及获取主线程)子线程执行完任务就自动死亡

    创建、启动线程
    NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
    [thread start];
    //线程一启动,就会在线程thread中执行self的run方法
    
  • (2).主线程相关用法

    +(NSThread *)mainThread;// 获得主线程
    
    -(BOOL)isMainThread;// 是否为主线程
    
    +(BOOL)isMainThread; // 是否为主线程
    
  • (3).其他用法

    • <1>获得当前线程

      NSThread *current = [NSThread currentThread];
      
    • <2>.线程的名字

      - (void)setName:(NSString*)n;
      -(NSString *)name;
      
  • (4).其他创建线程方式

    • <1>.创建线程后自动启动线程

      [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
      
    • <2>.隐式创建并启动线程(其实也就是在后台创建子线程)

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

    上述2种创建线程方式的优缺点

  • 优点:简单快捷

  • 缺点:无法对线程进行更详细的设置

NSThread的code 密码: gsq4

  • (5).线程的状态
线程的状态
  • (6).控制线程状态

    • <1>.启动线程

       -(void)start;
      

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

    • <2>.阻塞(暂停)线程

      +(void)sleepUntilDate:(NSDate *)date;// 进入阻塞状态
      
      +(void)sleepForTimeInterval:(NSTimeInterval)ti;// 进入阻塞状态
      
    • <3>.强制停止线程

      +(void)exit; //进入死亡状态  例如:  [NSThread exit];//线程强制退出
      

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

  • (7).多线程的安全隐患:资源共享

    <1>.1块资源可能会被多个线程共享,也就是多个线程可能会访问同一块资源

    <2>. 比如多个线程访问同一个对象、同一个变量、同一个文件

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

第一个例子: 银行取钱

银行取钱

第二个例子: 售票

售票
安全问题分析
  • <4>.安全隐患解决– 互斥锁 : 加锁是消耗资源的

    安全解决方案

  • (1).互斥锁使用格式

  • (2).互斥锁的优缺点

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

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

  • (4).相关专业术语:线程同步

    • 线程同步的意思是:多条线程在同一条线上执行(按顺序地执行任务)

    • 互斥锁,就是使用了线程同步技术

抢票资源的解决问题

抢票资源的解决问题

卖票抢夺资源代码 密码: bwgb

六.线程之间的通信

  • <1>.原子和非原子属性
    OC在定义属性时有nonatomicatomic两种选择

    • atomic:原子属性,为setter方法加锁(默认就是atomic

    • nonatomic:非原子属性,不会为setter方法加锁:避免资源消耗

  • <2>.原子非原子属性的选择

    • nonatomicatomic对比
    • atomic:线程安全,需要消耗大量的资源
    • nonatomic:非线程安全,适合内存小的移动设备
  • <3>.iOS开发的建议

    • 所有属性都声明为nonatomic

    • 尽量避免多线程抢夺同一块资源

    • 尽量将加锁、资源抢夺的业务逻辑交给服务器端处理,减小移动客户端的压力

  • <4>.什么叫做线程间通信?

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

  • <5>.线程间通信的体现

  • (1).1个线程传递数据给另1个线程

  • (2).在1个线程中执行完特定任务后,转到另1个线程继续执行任务

  • <6>.线程间通信常用方法

线程间通信常用方法

举个例子:用UIImageView加载图片

//1.获取图片的路径
NSString *stringPath = @"http://h.hiphotos.baidu.com/image/h%3D360/sign=48771214b08f8c54fcd3c3290a282dee/c9fcc3cec3fdfc0375633742d03f8794a4c22635.jpg";
//开始时间(秒数,从1970年0点0时0分0秒开始算起)
CFTimeInterval begin = CFAbsoluteTimeGetCurrent();

//2.根据图片的路径去下载图片
NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]];
//结束时间
CFTimeInterval end = CFAbsoluteTimeGetCurrent();

NSLog(@"开始时间=%f 结束时间=%f 消耗时间==%f",begin,end,end -begin);

//3.加载下载好的图片
self.picture.image = [UIImage imageWithData:data];

获取时间间隔的方式:

1.第一种获取时间
NSDate *begin = [NSDate date];
//根据图片的路径去下载图片
NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]];
//结束时间
NSDate *end = [NSDate date];
NSLog(@"开始时间=%@ 结束时间=%@ 消耗时间==%f",begin,end,[end timeIntervalSinceDate:begin]);

2.第二种获取时间
//开始时间(秒数,从1970年0点0时0分0秒开始算起)
CFTimeInterval begin = CFAbsoluteTimeGetCurrent();
//2.根据图片的路径去下载图片
NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringPath]];
//结束时间
CFTimeInterval end = CFAbsoluteTimeGetCurrent();
NSLog(@"开始时间=%f 结束时间=%f 消耗时间==%f",begin,end,end -begin);
  • <7>.子线程下载图片,在主线程刷新UI

    1.跳转刷新UI

    [self performSelectorOnMainThread:@selector(refreshUI:) withObject:image waitUntilDone:YES];
    
    /**
     *  刷新UI
     */
    -(void)refreshUI:(UIImage *)image
    {
        //3.加载下载好的图片
       self.picture.image = image;
    }
    

    2.直接不跳转刷新UI

    [self.picture performSelector:@selector(setImage:) onThread:[NSThread mainThread] withObject:image waitUntilDone:YES];
    

最后解释一下方法的最后一个参数waitUntilDone:YES或者NO的问题

YES:意思是刷新UI之后再走子线程之后的其他任务
NO:意思是主线程刷新的同时,其他线程也在执行任务

YES与NO的区别

线程通信方式的demo 密码: 85x4

七.GCD

  • <1> 什么是GCD ?
    GCD全称是Grand Central Dispatch,可译为“牛逼的中枢调度器”,纯C语言,提供了非常多强大的函数

  • <2>.GCD的优势

  • GCD是苹果公司为多核的并行运算提出的解决方案

  • GCD会自动利用更多的CPU内核(比如双核、四核)

  • GCD会自动管理线程的生命周期(创建线程、调度任务、销毁线程)

  • 程序员只需要告诉GCD想要执行什么任务,不需要编写任何线程管理代码

  • <3>.GCD中有2个核心概念:任务队列

    • 任务:执行什么操作
    • 队列:用来存放任务
  • <4>.GCD的使用就2个步骤

    • 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);
      同步和异步的区别:
      同步:只能在当前线程中执行任务,不具备开启新线程的能力
      异步:可以在新的线程中执行任务,具备开启新线程的能力

  • <6>.GCD的队列可以分为2大类型

    1.并发队列(Concurrent Dispatch Queue

    • (1).可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)

    • (2).并发功能只有在异步(dispatch_async)函数下才有效

    2.串行队列(Serial Dispatch Queue

    • 让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
  • <7>.有4个术语比较容易混淆:同步、异步、并发、串行

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

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

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

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

  • <8>.并发队列

    • GCD默认已经提供了全局的并发队列,供整个应用使用,不需要手动创建

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

    • 获得全局并发队列

      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 // 后
      
  • <9>.全局并发队列与全局串行队列获取方式

  • 并发队列:创建的2种方式
    获得全局并发队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    获取不是全局的并发队列
    dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);

  • 串行队列:创建的2种方式
    获得全局串行队列
    dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_SERIAL);
    dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL);
    dispatch_release(queue);非ARC需要释放手动创建的队列

  • <10>.主队列

    • 主队列(跟主线程相关联的队列)

    • 主队列是GCD自带的一种特殊的串行队列

    • 放在主队列中的任务,都会放到主线程中执行

    • 使用dispatch_get_main_queue()获得主队列

      dispatch_queue_t queue = dispatch_get_main_queue();
      
  • <11>.各种队列的执行效果

各种队列的执行效果

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

下面写一个GCD线程阻塞的代码

GCD线程阻塞的代码
  • <12>.GCD主线程与子线程之间的通信

    从子线程回到主线程

    GCD主线程与子线程之间的通信

  • <13>.GCD里面还有一个来执行任务的函数:barrier是栅栏

    • barrier是栅栏的意思,在它前面的任务执行完之后才执行,而且后面的任务等它执行结束后才去执行.
  • 注意 这个队列queue不能是全局的并发队列

       dispatch_queue_t queue = dispatch_queue_create("12235", DISPATCH_QUEUE_CONCURRENT);
    
       dispatch_barrier_async(queue, ^{
    
           NSLog(@"您在执行barrier");
    
        });
    

例如下面的代码:

-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
     dispatch_queue_t queue = dispatch_queue_create("12235", DISPATCH_QUEUE_CONCURRENT);

     dispatch_async(queue, ^{
          NSLog(@"1111");
     });
     dispatch_async(queue, ^{
         NSLog(@"2222"); 
     });
    dispatch_barrier_async(queue, ^{
         NSLog(@"您在执行barrier"); 
    });
    dispatch_async(queue, ^{
        NSLog(@"3333");  
    });
    dispatch_async(queue, ^{
        NSLog(@"4444");
    });
}

打印结果如下

打印结果如下

八.iOS常见的延时执行有2种方式

  • <1>.调用NSObject的方法

     2秒后再调用self的run方法
    [self performSelector:@selector(run) withObject:nil afterDelay:2];
    
  • <2>.使用GCD函数
    2s后的代码在哪里执行是和队列有关系的

    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
      
            NSLog(@"2s了");
    });
    
  • <3>.NSTimer定时器

    NO代表不重复,定时器执行完就进行销毁,如果是YES就代表每隔2s调用一次run方法
    [NSTimer scheduledTimerWithTimeInterval:2 target:self selector:@selector(run) userInfo:nil repeats:NO];

九.一次性代码

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

  static dispatch_once_t onceToken;
  dispatch_once(&onceToken,^{

     只执行1次的代码(这里面默认是线程安全的)

  });

提醒:一次性代码慎用,它是程序在运行过程中只执行一次

十.剪切利用多线程分析 (剪切是耗时的,要放到子线程里面)

剪切利用多线程分析
  • 1.传统的剪切方式
#pragma mark 传统的剪切文件
-(void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    NSString *form = @"/Users/jinqianxiang/Desktop/Form";
    NSString *to = @"/Users/jinqianxiang/Desktop/To";
    
    /**
     *  创建文件管理对象
     */
    NSFileManager *filemanger = [NSFileManager defaultManager];
    //获取要剪切的文件夹里面的每个对象名字
    NSArray *array = [filemanger subpathsAtPath:form];
    
    for (NSString *subpath in array) {
        //全路径
        NSString *formPath = [form stringByAppendingPathComponent:subpath];
        NSString *toPath = [to stringByAppendingPathComponent:subpath];
      
       dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
          
          //剪切(全路径剪切)
          [filemanger moveItemAtPath:formPath  toPath:toPath error:nil];
       
        });
    }
}
  • 2.比较快的剪切方式

    -(void)apply
    {
       NSString *form = @"/Users/jinqianxiang/Desktop/Form";
       NSString *to = @"/Users/jinqianxiang/Desktop/To";
    
        /**
         *  创建文件管理对象
         */
       NSFileManager *filemanger = [NSFileManager defaultManager];
       //获取要剪切的文件夹里面的每个对象名字
       NSArray *array = [filemanger subpathsAtPath:form];
    
       dispatch_apply(array.count, dispatch_get_global_queue(0, 0), ^(size_t index) {
      
      //NSLog(@"456--%@",[NSThread currentThread]);
      
      NSString *sunPath = array[index];
      //全路径
      NSString *formPath = [form stringByAppendingPathComponent:sunPath];
      NSString *toPath = [to stringByAppendingPathComponent:sunPath];
    
      //剪切(全路径剪切)
      [filemanger moveItemAtPath:formPath  toPath:toPath error:nil];
      
      NSLog(@"---%@---%zd",[NSThread currentThread],index);
      
      });
    }
    
比较快的剪切方式

文件的剪切demo 密码: 7edp

十一.GCD队列组和栅栏(barrier)一样的效果:确定线程的优先级顺序

  • 有这么1种需求?
  • 首先:分别异步执行2个耗时的操作
  • 其次:等2个异步操作都执行完毕后,再回到主线程执行操作

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

dispatch_group_t group =  dispatch_group_create();
// 1.
dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),^{

        //执行1个耗时的异步操作

});
//2.
dispatch_group_async(group,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0),^{

      //执行1个耗时的异步操作

});
//3.
dispatch_group_notify(group,dispatch_get_main_queue(),^{

     //等前面的异步操作都执行完毕后,回到主线程...

});

这样就是1和2执行完了才会执行3

下面以两张图片合成为例:

两张图片合成为例

两张图片合成demo 密码: 3w5f

关键性代码:

 /**
 *  3.将两个图片合成
 */
dispatch_group_notify(group, queue, ^{
    /**
     *  开启新的图形上下文
     */
    UIGraphicsBeginImageContext(CGSizeMake(200, 200));
    
    //绘制图片
    [self.image1 drawInRect:CGRectMake(0, 0, 200, 100)];
    //绘制图片
    [self.image2 drawInRect:CGRectMake(0, 100, 200, 100)];
    
    /**
     *  取得上下文里面的图片
     */
    UIImage *image = UIGraphicsGetImageFromCurrentImageContext();
    
    /**
     *  结束上下文
     */
    UIGraphicsEndImageContext();
    
    /**
     *  4.进入主队列加载合成的图片
     */
    
    dispatch_async(dispatch_get_main_queue(), ^{
        
        self.imageView.image = image;
        
  });

十二.GCD单例模式

  • 1.单例模式的作用

    • 可以保证在程序运行过程,一个类只有一个实例,而且该实例易于供外界访问

    • 从而方便地控制了实例个数,并节约系统资源

  • 2.单例模式的使用场合

    • 在整个应用程序中,共享一份资源(这份资源只需要创建初始化1次)
  • 3.单例模式在ARC\MRC环境下的写法有所不同,需要编写2套不同的代码

    • 可以用宏判断是否为ARC环境
 #if __has_feature(objc_arc)
 //ARC
 #else
 //MRC
 #endif
  • 4.GCD单例模式1(比较简单)
#import "PersonMessages.h"

static PersonMessages *personMessages;
@implementation PersonMessages

 +(instancetype)allocWithZone:(struct _NSZone *)zone
 {

     static dispatch_once_t onceToken;

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

  return personMessages;
}
@end




说明:不管是alloc还是allocWithZone 都会调用allocWithZone

  • 5.完整的一个单例(粒)对象的.m包含3个部分

下面还是以PersonMessages类为例
.h里面

#import <Foundation/Foundation.h>

@interface PersonMessages : NSObject

+(instancetype)sharePersonMessages;

@end

.m里面

#import "PersonMessages.h"
@implementation PersonMessages
static PersonMessages *personMessages;
/**
 *  1.保证调用 [ PersonMessages sharePersonMessages] 只会调用一次init
 *
 *  @return personMessages
 */
+(instancetype)sharePersonMessages
{
    static dispatch_once_t onceToken;

    dispatch_once(&onceToken, ^{
    
    personMessages = [[self alloc]init];
    
    });

  return personMessages;
}

/**
 *  2.外面调用n次访问同一个对象
 *
 *  @return personMessages
 */
+(instancetype)allocWithZone:(struct _NSZone *)zone
{
   static dispatch_once_t onceToken;

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

   return personMessages;
}

/**
 *  3.外面进行copy的时候还是同一个对象
 *
 *  @return personMessages;
 */
 -(id)copy
{
    return personMessages;
}
@end
完整的单例(粒)

解释一下:

1.static:意思防止外面人访问更改

static PersonMessages *personMessages;

2.once默认是安全的(已经加锁), onceToken是来记录访问过block

dispatch_once(&onceToken, ^{

        personMessages = [super allocWithZone:zone];

    });
  • 6.对单例(粒)的一种封装,只需要传类名

下面我对单例类进行封装解释

对单例类进行封装

GCD单例的封装 密码: yxan
传统单例的封装 密码: xxne

使用方法:图中3步

.h

1

.m

2

十三.NSOperation

  • <1>.NSOperation的作用

    配合使用NSOperationNSOperationQueue也能实现多线程编程

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

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

注意:

  • <3>.NSOperation的子类

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

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

    • (1).NSInvocationOperation

    • (2).NSBlockOperation

    • (3).自定义子类继承NSOperation,实现内部相应的方法

  • <5>.NSInvocationOperation

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

  • 2.调用start方法开始执行操作

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

  • 3.注意:

    默认情况下,调用了start方法后并不会开一条新线程去执行操作,而是在当前线程同步执行操作

    只有将NSOperation放到一个NSOperationQueue中,才会异步执行操作(也就是进入子线程)

NSInvocationOperation
  • <6>.NSBlockOperation

** 一张图**


NSBlockOperation
NSOperationQueue的作用

- 如果将`NSOperation`添加到`NSOperationQueue`(操作队列)中,系统会**自动异步执行**NSOperation中的操作:相当于`start`

另外还可以直接用队列添加Operation

      /**
        *  1.创建队列
        */
       NSOperationQueue *operationQueue = [NSOperationQueue new];

      /**
       *  特殊情况,队列直接添加operation(添加任务)
       */
          [operationQueue addOperationWithBlock:^{
    
             NSLog(@"%@",[NSThread currentThread]);
         }];
  • <7>.自定义创建NSOperation
1.自定义创建NSOperation
2.自定义创建NSOperation

注意:放到队列之后,它会自动开启start

NSOperation创建的3中形式 密码: qaex

  • <8>.最大并发数

    • 并发数是指:同时执行的任务数,比如,同时开3个线程执行3个任务,并发数就是3
  • 最大并发数也就是NSOperationQueue的属性
    maxConcurrentOperationCount,当=1时就是串行队列了

     /**
      *  1.创建队列
      */
      NSOperationQueue *operationQueue = [NSOperationQueue new];
    
     /**
      *  2.设置最大并发数
     */
      operationQueue.maxConcurrentOperationCount = 1;
    

    最大并发数只要大于1,是几就代表几条线程同时执行,执行完的线程有可能会被重复利用

最大并发数 密码: xxwk

  • <9>.队列的取消暂停恢复(操作对象是:队列 NSOperationQueue)

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

提示:在自定义的NSOperation的-(void)main{}方法里面,如果线程取消了,我们应该进行判断,防止性能消耗

取消队列的所有操作
  • 暂停和恢复队列

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

举个例子:

暂停或者取消队列

NSOperationQueue的挂起和取消 密码: 58is

  • <10>.操作依赖

    注意:依赖必须添加到NSOperation对象添加到队列之前进行依赖

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

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

      [operationB addDependency:operationA];// 操作B依赖于操作A
      
    • 可以在不同queue的NSOperation之间创建依赖关系(添加的是NSOperation的对象,不管是不是在同一个队列:也可以说能够跨队列)

跨队列
  • <11>.操作的监听
    可以监听一个操作的执行完毕

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

最后:提一下图片的缓存机制

  • 内存缓存

  • 沙盒缓存

  • 硬盘缓存

    /**
     *  1.内存缓存图片
     */
    @property(nonatomic,strong) NSMutableDictionary *dataDictionary;
    
    NSString *stringImage = [NSString stringWithFormat:@"%@",self.plist[indexPath.row]];
    
    //先从内存缓存中取出图片
    UIImage *image = self.dataDictionary[stringImage];
    
    if (image) {//内存有图片
    
    cell.imageCellPicture.image = image;
    
    }else{// 内存中没有图片
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
    
    //获取Library/Caches 文件夹
    NSString *cachesPath = [NSSearchPathForDirectoriesInDomains(NSCachesDirectory, NSUserDomainMask, YES) firstObject];
     //获取文件名(也就是取得路径的最后一个路径)
     NSString *fileName = [stringImage lastPathComponent];
     //计算出全路径
     NSString *filePath = [cachesPath stringByAppendingPathComponent:fileName];
     //取出图片
     NSData *data = [NSData dataWithContentsOfFile:filePath];
    
    if(data){//直接利用沙盒中图片
       
       dispatch_async(dispatch_get_main_queue(), ^{
           
           cell.imageCellPicture.image = [UIImage imageWithData:data];
           
       });
        //存到字典中
       self.dataDictionary[stringImage] = cell.imageCellPicture.image;
       
     }else
    {   // 下载图片
       data = [NSData dataWithContentsOfURL:[NSURL URLWithString:stringImage]];
       
       UIImage *image1 = [UIImage imageWithData:data];
       
       dispatch_async(dispatch_get_main_queue(), ^{
           
           cell.imageCellPicture.image = image1;
       });
       
       // 存到字典中
       self.dataDictionary[stringImage] = cell.imageCellPicture.image;
       // 将图片文件数据写入沙盒中
       [data writeToFile:filePath atomically:YES];
      }
     });
    }
    

图片缓存代码<不完善> 密码: wjhv

沙盒缓存

完善的图片缓存 密码: gr3k

无沙盒缓存

最后再总结一下队列类型

GCD 的队列类型

  • 1.并发队列

    • 自己创建的

    • 全局

      并发队列:创建的2种方式

      获得全局并发队列
      dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
      获取不是全局的并发队列
      dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_CONCURRENT);
      
  • 2.串行队列

    • 主队列

    • 自己创建的

      串行队列:创建的2种方式
      
      获得全局串行队列
      dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", DISPATCH_QUEUE_SERIAL);
      dispatch_queue_t queue = dispatch_queue_create("com.520it.queue", NULL);
      dispatch_release(queue);非ARC需要释放手动创建的队列
      

NSOperationQueue队列类型

  • 主队列

    • [NSOperationQueue mainQueue];
    • 凡是添加到主队列中的任务NSOperation,都会到主线程中执行
  • 非主队列(其他队列)

    • [[NSOperationQueue alloc]init];
    • 同时包含了:串行,并发功能
    • 添加到这种队列中的任务(NSOperation),就会自动放到主线程中执行
iOS进阶
Web note ad 1