美文网首页
iOS开发中多线程的使用

iOS开发中多线程的使用

作者: SanMao_SFW | 来源:发表于2015-12-08 20:44 被阅读770次

    互斥锁/线程同步(@synchronized(对象))

    • 用途:为了解决一块资源被多个线程共享造成的数据紊乱数据安全问题
    • 只要被@synchronized的{}包裹起来的代码,同一时刻就只能被一个线程执行
    • 注意:
    1. 只要加锁就会消耗性能
    2. 加锁必须传递一个对象,作为锁(一般都是传self)
    3. 如果想真正的锁住代码,那么多个线程必须使用同一把锁才行
    4. 加锁的时候尽量缩小范围,因为范围越大性能就越低

    多线程的实现方案

    1.Pthread(C):基本不用
    2.NSThread(OC):可拿到线程对象,设置线程的一些属性,结束线程等
    3.GCD(C):用的最多,使用最简单(不能拿到线程,开始了就很难手动结束)
    4.NSOperation(OC):抽象类,要使用其子类

    Pthread

    // 第一个参数: 线程的代号(当做就是线程)
    // 第二个参数: 线程的属性
    // 第三个参数: 指向函数的指针, 就是将来线程需要执行的方法
    // 第四个参数: 给第三个参数的指向函数的指针 传递的参数
    pthread_t threadId;
    // 只要create一次就会创建一个新的线程
    pthread_create(&threadId , NULL, &demo, "lnj");
    

    NSThread

    • 注意:如果正在执行系统分离出来的线程(子线程)时,系统内部会retain当前线程,只有线程中的方法执行完毕,系统才会将其释放(release)

    • 创建方式一(可拿到子线程对象设置一些属性,需要手动开启子线程)

        // 创建子线程
        NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run) object:nil];
        
        // 设置线程的其他属性
        thread.name = @"second";
        
        // 开启子线程
        [thread start];
    
    • 创建方式二(不能拿到子线程对象,不需要手动开启子线程,快速
        // 创建子线程
        [NSThread detachNewThreadSelector:@selector(run) toTarget:self withObject:nil];
        ```
    
    - 创建方式三(系统自动创建子线程并在self的@selector方法中执行,**快速**)
        ```objc
        // 第三种创建方式
        [self performSelectorInBackground:@selector(run) withObject:nil];
    
    • 常用方法
    + (NSThread *)mainThread; // 获得主线程
    - (BOOL)isMainThread; // 是否为主线程
    + (BOOL)isMainThread; // 是否为主线程
    
    // 获取当前线程(最常用)
    [NSThread currentThread]; 
    
    // 线程的调度优先级,调度优先级的取值范围是0.0 ~ 1.0,默认0.5,值越大,优先级越高
    + (double)threadPriority;
    + (BOOL)setThreadPriority:(double)p;
    - (double)threadPriority;
    - (BOOL)setThreadPriority:(double)p;
    
    // 线程的名字
    - (void)setName:(NSString *)n;
    - (NSString *)name;
    
    // 阻塞(暂停)线程,**如果想实现延长启动图片的显示时间可在application的didFinish方法中用此方法让线程睡一会**
    + (void)sleepUntilDate:(NSDate *)date;
    + (void)sleepForTimeInterval:(NSTimeInterval)ti;
    
    // 强制停止线程
    + (void)exit;
    

    GCD

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

    • GCD中有2个核心概念

      • 任务:执行什么操作
      • 队列:用来存放任务
    • GCD的使用就2步
      1.定制任务(确定要执行什么)
      2.将任务添加到队列(GCD会自动将队列中的任务取出,放到对应的线程中执行,任务的取出遵循队列的FIFO原则:先进先出,后进后出)

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

      • 同步:只能在当前线程中执行任务,不具备开启新线程的能力
    // queue:队列
    // block:任务
    dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);   
    
    • 异步:可以在新的线程中执行任务,具备开启新线程的能力
    dispatch_async(dispatch_queue_t queue, dispatch_block_t block);
    
    • 队列类型
      • 串行:让任务一个接着一个地执行(一个任务执行完毕后,再执行下一个任务)
    // 串行队列的创建
    dispatch_queue_t queue = dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
        // 两个参数分别是:队列的名称,队列的类型
        // 创建串行队列(队列类型传递NULL或者DISPATCH_QUEUE_SERIAL)
    
    • 并发:可以让多个任务并发(同时)执行(自动开启多个线程同时执行任务)并发功能只有在异步(dispatch_async)函数下才有效
    // 并发队列的创建,两个参数分别是:队列的名称,队列的类型
    dispatch_queue_t queue = dispatch_queue_create(const char *label, dispatch_queue_attr_t attr);
    
    - 获取全局并发队列
    
    // GCD默认已经提供了全局的并发队列,供整个应用使用,可以无需手动创建
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
        // 第一个参数是优先级,传0即可,第二参数暂时无用,传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 // 后台
    
    - 获取主队列(**放在主队列中的任务,都会放到主线程中执行**)
    
    // 主队列是GCD自带的一种特殊的串行队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    - *注意:使用sync函数往当前串行队列中添加任务,会卡住当前的串行队列*
    
    • 任务函数和队列类型的搭配使用
    /*
     同步 + 主队列 = 需要记住的就一点: 同步函数不能搭配主队列使用
     注意: 如果是在子线程中调用同步函数 + 主对列 是可以执行的
     */
    - (void)syncMian
    {
        // 主队列, 只要将任务放到主队列中, 那么任务就会在主线程中执行
        dispatch_queue_t queue = dispatch_get_main_queue();
        
        // 需要记住的就一点: 同步函数不能搭配主队列使用
        dispatch_sync(queue, ^{
            NSLog(@"1 - %@", [NSThread currentThread]);
        });
        dispatch_sync(queue, ^{
            NSLog(@"2 - %@", [NSThread currentThread]);
        });
        dispatch_sync(queue, ^{
            NSLog(@"3 - %@", [NSThread currentThread]);
        });
        
        NSLog(@"++++++++++++++");
    }
    
    /*
     异步 + 主队列 = 不会开启新的线程
     */
    - (void)asyncMain
    {
        // 主队列, 只要将任务放到主队列中, 那么任务就会在主线程中执行
        dispatch_queue_t queue = dispatch_get_main_queue();
        // 如果任务放在主队列中, 哪怕是异步方法也不会创建新的线程
        dispatch_async(queue, ^{
            NSLog(@"1 - %@", [NSThread currentThread]);
        });
        dispatch_async(queue, ^{
            NSLog(@"2 - %@", [NSThread currentThread]);
        });
        dispatch_async(queue, ^{
            NSLog(@"3 - %@", [NSThread currentThread]);
        });
    }
    
    /*
     同步 + 串行 = 不会创建新的线程
     注意: 如果是同步函数, 只要代码执行到了同步函数的那一行, 就会立即执行任务, 只有任务执行完毕才会继续往后执行
     */
    - (void)syncSerial
    {
        // 1.创建队列
        /*
         正是因为线程默认就是串行, 所以创建串行队列的时候, 队列类型可以不传值
         */
        //    dispatch_queue_t queue = dispatch_queue_create("com.520it.lnj", DISPATCH_QUEUE_SERIAL);
        dispatch_queue_t queue = dispatch_queue_create("com.520it.lnj", NULL);
        
        // 2.添加任务
        dispatch_sync(queue, ^{
            NSLog(@"1 - %@", [NSThread currentThread]);
        });
        dispatch_sync(queue, ^{
            NSLog(@"2 - %@", [NSThread currentThread]);
        });
        dispatch_sync(queue, ^{
            NSLog(@"3 - %@", [NSThread currentThread]);
        });
        
        NSLog(@"%s", __func__);
    }
    
    /*
     同步 + 并行 = 不会开启新的线程
     注意: 能不能开启新的线程, 和并行/串行没有关系, 只要函数是同步还是异步
     */
    - (void)syncConcurrent
    {
        // 1.创建队列
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        
        // 2.添加任务
        dispatch_sync(queue, ^{
            NSLog(@"1 - %@", [NSThread currentThread]);
        });
        dispatch_sync(queue, ^{
            NSLog(@"2 - %@", [NSThread currentThread]);
        });
        dispatch_sync(queue, ^{
            NSLog(@"3 - %@", [NSThread currentThread]);
        });
        NSLog(@"%s", __func__);
    }
    /*
     异步 + 串行 = 会创建新的线程, 但是只会创建一个新的线程, 所有的任务都在这一个新的线程中执行
     异步任务, 会先执行完所有的代码, 再在子线程中执行任务
     */
    - (void)asyncSerial
    {
        // 1.创建队列
        dispatch_queue_t queue = dispatch_queue_create("com.520it.lnj", DISPATCH_QUEUE_SERIAL);
        
        // 2.添加任务
        dispatch_async(queue, ^{
            NSLog(@"1 - %@", [NSThread currentThread]);
        });
        dispatch_async(queue, ^{
            NSLog(@"2 - %@", [NSThread currentThread]);
        });
        dispatch_async(queue, ^{
            NSLog(@"3 - %@", [NSThread currentThread]);
        });
        NSLog(@"%s", __func__);
    }
    
    /*
     异步 +  并行 = 会开启新的线程
     */
    - (void)asynConcurrent
    {
        /*
         第一个参数: 队列
         第二个参数: 任务
         */
        // 1.创建队列
        /*
         第一个参数: 队列的名称
         第二个参数: 队列的类型
         */
        //    dispatch_queue_t queue = dispatch_queue_create("com.520it.lnj", DISPATCH_QUEUE_CONCURRENT);
        
        // 其实系统内部已经给我们提供了一个现成的并发队列
        /*
         第一个参数: iOS8以前是线程的优先级/ iOS8以后代表服务质量
         iOS8以前
         *  - DISPATCH_QUEUE_PRIORITY_HIGH: 2
         *  - DISPATCH_QUEUE_PRIORITY_DEFAULT: 0
         *  - DISPATCH_QUEUE_PRIORITY_LOW: -2
         *  - DISPATCH_QUEUE_PRIORITY_BACKGROUND: -32768
         
         iOS8开始, 取值都是十六进制
         *  - QOS_CLASS_USER_INTERACTIVE 用户交互(用户迫切的想执行任务, 不要在这种服务质量下做耗时的操作)
         *  - QOS_CLASS_USER_INITIATED   用户需要
         *  - QOS_CLASS_DEFAULT          默认(重置队列)
         *  - QOS_CLASS_UTILITY          实用工具(耗时的操作放在这里)
         *  - QOS_CLASS_BACKGROUND
         *  - QOS_CLASS_UNSPECIFIED      没有设置任何优先级
         第二个参数: 系统保留的参数, 永远传0
         */
        // 1.获取全局的并发队列
        dispatch_queue_t queue = dispatch_get_global_queue(0 , 0);
        
        // 2.添加任务到队列
        // 文档说明是FIFO原则, 先进先出
        // 打印结果不正确的原因: 线程的执行速度可能不一样, 有得快一些, 有的慢一些
        dispatch_async(queue, ^{
            NSLog(@"1 - %@", [NSThread currentThread]);
        });
        dispatch_async(queue, ^{
            NSLog(@"2 - %@", [NSThread currentThread]);
        });
        dispatch_async(queue, ^{
            NSLog(@"3 - %@", [NSThread currentThread]);
        });
        NSLog(@"%s", __func__);
    }
    
    • GCD的更多函数使用(延迟执行delay,只执行一次once,快速迭代apply,栅栏barrier,队列组group)请移步GCD更多函数使用

    NSOperation

    • 简介

      • NSOperation是个抽象类,并不具备封装操作的能力,必须使用它的子类
      • 使用NSOperation子类的方式有3种
        • NSInvocationOperation
        • NSBlockOperation
        • 自定义子类继承NSOperation,实现内部相应的方法
    • 配合使用NSOperation和NSOperationQueue也能实现多线程编程
      1.先将需要执行的操作封装到一个NSOperation对象中
      2.然后将NSOperation对象添加到NSOperationQueue中
      3.系统会自动将NSOperationQueue中的NSOperation取出来
      4.将取出的NSOperation封装的操作放到一条新线程中执行

    • NSOperation使用注意

    • 用NSOperation的子类创建的任务如果没有加入队列中,需要手动调用start方法,且默认不会增加新线程是在主线程中执行,加入队列中系统会自动执行

    • 用NSBlockOperation创建任务后调用addExecutionBlock:追加的任务默认是在子线程中执行

    • 如果用NSOperationQueue创建了队列,且任务加入了队列中,就不需要调用start方法,系统会自动从queue中取出任务在子线程中执行

    • NSOperationQueue创建队列后的快速添加任务方法

      // 此方法系统内部会自动封装成一个NSBlockOperation然后再添加到队列中
      [queue addOperationWithBlock:^{
          NSLog(@"4---%@",[NSThread currentThread]);
      }];
      
    • NSOperation的自定义任务,继承自NSOperation,实现main方法,在main方法中输入需要执行的任务,将自定义的任务加入队列后,系统会自动在子线程中执行任务。

    #import "SFWOperation.h" // SFWOperation是自定义的继承自NSOperation的类
    @implementation SFWOperation
    
    // 只要将任务添加到了队列中,系统会自动执行自定义任务中的main方法
    - (void)main{
     
        // 在这里写上需要执行的任务
        NSLog(@"%@",[NSThread currentThread]);
        for (int i = 0; i< 10000; i++) {
            NSLog(@"%d",i);
        }
    }
    @end
    
    • 参数的使用

    • maxConcurrentOperationCount最大并发数

      • 自己创建的队列默认是并发,如果设置maxConcurrentOperationCount = 1,就是串行
      • 注意: 不能设置为0, 如果设置为0就不执行任务
      • 默认情况下maxConcurrentOperationCount = -1
      • 在开发中并发数最多尽量不要超过5~6条
    • suspended暂停任务

      • 只要设置队列的suspended为YES,那么就会暂停队列中其它任务的执行
      • 也就是说不会再继续执行没有执行到的任务
      • 只要设置队列的suspended为NO, 那么就会恢复队列中其它任务的执行
      • 注意:
        • 设置为暂停之后, 不会立即暂停
        • 会继续执行当前正在执行的任务, 直到当前任务执行完毕, 就不会执行下一个任务了
        • 也就是说, 暂停其实是暂停下一个任务, 而不能暂停当前任务
        • 暂停是可以恢复的
    • cancelAllOperations取消任务方法

      • 取消队列中所有的任务的执行
      • 取消和暂停一样, 是取消后面的任务, 不能取消当前正在执行的任务
      • 注意: 取消是不可以恢复的
    • addDependency:依赖方法

      // op3 依赖 op1,只有等op1的操作做完了以后才会开始op3的操作
      [op3 addDependency:op1];
      
    • completionBlock:监听方法

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

    线程间通信

    • 1个线程传递数据给另1个线程
    • 在1个线程中执行完特定任务后,转到另1个线程继续执行任务
    • 常用方法:
    - (void)performSelectorOnMainThread:(SEL)aSelector withObject:(id)arg waitUntilDone:(BOOL)wait;
    
    - (void)performSelector:(SEL)aSelector onThread:(NSThread *)thr withObject:(id)arg waitUntilDone:(BOOL)wait;
        // waitUntilDone的含义: 
        如果传入的是YES: 那么会等到主线程中的方法执行完毕, 才会继续执行下面其他行的代码
        如果传入的是NO: 那么不用等到主线程中的方法执行完毕, 就可以继续执行下面其他行的代码
    
    • 从子线程回到主线程(加入主队列)
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执行耗时的异步操作...
          dispatch_async(dispatch_get_main_queue(), ^{
            // 回到主线程,执行UI刷新操作
            });
    });
    
    - (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event{
    
        // 创建队列,获取全局并行队列
        dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
        
        // 添加下载任务到子线程中
        dispatch_async(queue, ^{
            
            NSLog(@"%@",[NSThread currentThread]);
            // 下载图片
            NSURL *url = [NSURL URLWithString:@"http://g.hiphotos.baidu.com/image/pic/item/1b4c510fd9f9d72aee889e1fd22a2834359bbbc0.jpg"];
            NSData *data = [NSData dataWithContentsOfURL:url];
            
            UIImage *image = [UIImage imageWithData:data];
            
            // 显示UI控件,将此任务加入到主队列中
            
            // 如果是通过异步函数添加任务,会先执行完所有代码再来执行block中的任务
            // 如果是通过同步函数添加的任务,会先执行完block中的任务再执行其他代码
            dispatch_async(dispatch_get_main_queue(), ^{
                NSLog(@"%@",[NSThread currentThread]);
                self.imageView.image = image;
            });
            
        });
    }
    

    相关文章

      网友评论

          本文标题:iOS开发中多线程的使用

          本文链接:https://www.haomeiwen.com/subject/ruvehttx.html