AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

iOS Principle：Thread（中）

2022-06-22 74
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： iOS Principle：Thread（中）

2.3 GCD 基本使用

1）GCD 核心概念

  • 队列和任务
  • 同步函数和异步函数

2）GCD 组合拳 🤣

异步函数：

  • 异步函数+并发队列：开启多条线程，并发执行任务
  • 异步函数+串行队列：开启一条线程，串行执行任务

同步函数：

  • 同步函数+并发队列：不开线程，串行执行任务
  • 同步函数+串行队列：不开线程，串行执行任务

主队列：

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

3）GCD 线程间通信

//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 常用小功能

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

dispatch_barrier_async(queue, ^{
    NSLog(@"--dispatch_barrier_async-");
});

延迟执行（延迟·控制在哪个线程执行）

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_global_  queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
    NSLog(@"---%@",[NSThread currentThread]);
});

一次性代码（注意不能放到懒加载）

- (void)once {
    //整个程序运行过程中只会执行一次
    //onceToken用来记录该部分的代码是否被执行过
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"-----");
    });
}

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

dispatch_apply(subpaths.count, queue, ^(size_t index) {
});

队列组（同栅栏函数）

//创建队列组
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t globalQueue = dispatch_get_global_queue(0, 0);
dispatch_group_enter(group);
//模拟多线程耗时操作
dispatch_group_async(group, globalQueue, ^{
    sleep(3);
    NSLog(@"%@---block1结束。。。",[NSThread currentThread]);
    dispatch_group_leave(group);
});
NSLog(@"%@---1结束。。。",[NSThread currentThread]);
dispatch_group_enter(group);
//模拟多线程耗时操作
dispatch_group_async(group, globalQueue, ^{
    sleep(3);
    NSLog(@"%@---block2结束。。。",[NSThread currentThread]);
    dispatch_group_leave(group);
});
NSLog(@"%@---2结束。。。",[NSThread currentThread]);
dispatch_group_notify(group, globalQueue, ^{
    NSLog(@"%@---全部结束。。。",[NSThread currentThread]);
});


2.4 NSOperation 基本使用

1）NSOperation、NSOperationQueue 简介

NSOperation、NSOperationQueue 是苹果提供给我们的一套多线程解决方案。实际上 NSOperation、NSOperationQueue 是基于 GCD 更高一层的封装，完全面向对象。但是比 GCD 更简单易用、代码可读性也更高。

为什么要使用 NSOperation、NSOperationQueue？

  • 1.可添加完成的代码块，在操作完成后执行。
  • 2.添加操作之间的依赖关系，方便的控制执行顺序。
  • 3.设定操作执行的优先级。
  • 4.可以很方便的取消一个操作的执行。
  • 5.使用 KVO 观察对操作执行状态的更改：isExecuteing、isFinished、isCancelled。

2）NSOperation、NSOperationQueue 操作和操作队列

既然是基于 GCD 的更高一层的封装。那么，GCD 中的一些概念同样适用于 NSOperation、NSOperationQueue。在 NSOperation、NSOperationQueue 中也有类似的任务（操作）和队列（操作队列）的概念。

操作（Operation）：

  • 执行操作的意思，换句话说就是你在线程中执行的那段代码。
  • 在 GCD 中是放在 block 中的。在 NSOperation 中，我们使用 NSOperation 子类 NSInvocationOperation、NSBlockOperation，或者自定义子类来封装操作。

操作队列（Operation Queues）：

  • 这里的队列指操作队列，即用来存放操作的队列。不同于 GCD 中的调度队列 FIFO（先进先出）的原则。NSOperationQueue 对于添加到队列中的操作，首先进入准备就绪的状态（就绪状态取决于操作之间的依赖关系），然后进入就绪状态的操作的开始执行顺序（非结束执行顺序）由操作之间相对的优先级决定（优先级是操作对象自身的属性）。
  • 操作队列通过设置最大并发操作数（maxConcurrentOperationCount）来控制并发、串行。
  • NSOperationQueue 为我们提供了两种不同类型的队列：主队列和自定义队列。主队列运行在主线程之上，而自定义队列在后台执行。

3）NSOperation、NSOperationQueue 使用步骤

NSOperation 需要配合 NSOperationQueue 来实现多线程。因为默认情况下，NSOperation 单独使用时系统同步执行操作，配合 NSOperationQueue 我们能更好的实现异步执行。

NSOperation 实现多线程的使用步骤分为三步：

  • 1.创建操作：先将需要执行的操作封装到一个 NSOperation 对象中。
  • 2.创建队列：创建 NSOperationQueue 对象。
  • 3.将操作加入到队列中：将 NSOperation 对象添加到 NSOperationQueue 对象中。

之后呢，系统就会自动将 NSOperationQueue 中的 NSOperation 取出来，在新线程中执行操作。

下面我们来学习下 NSOperation 和 NSOperationQueue 的基本使用。

4）NSOperation 和 NSOperationQueue 基本使用

4.1）创建操作

NSOperation 是个抽象类，不能用来封装操作。我们只有使用它的子类来封装操作。我们有三种方式来封装操作。

  • 使用子类 NSInvocationOperation
  • 使用子类 NSBlockOperation
  • 自定义继承自 NSOperation 的子类，通过实现内部相应的方法来封装操作。

在不使用 NSOperationQueue，单独使用 NSOperation 的情况下系统同步执行操作，下面我们学习以下操作的三种创建方式。

4.1.1）使用子类 NSInvocationOperation

/**
* 使用子类 NSInvocationOperation
*/
- (void)useInvocationOperation {
    // 1.创建 NSInvocationOperation 对象
    NSInvocationOperation *op = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
    // 2.调用 start 方法开始执行操作
    [op start];
}
/**
* 任务1
*/
- (void)task1 {
    for (int i = 0; i < 2; i++) {
        [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
        NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
    }
}

运行结果

image.png

可以看到：在没有使用 NSOperationQueue、在主线程中单独使用使用子类 NSInvocationOperation 执行一个操作的情况下，操作是在当前线程执行的，并没有开启新线程。

如果在其他线程中执行操作，则打印结果为其他线程

// 在其他线程使用子类 NSInvocationOperation
[NSThread detachNewThreadSelector:@selector(useInvocationOperation) toTarget:self withObject:nil];


image.png


可以看到：在其他线程中单独使用子类 NSInvocationOperation，操作是在当前调用的其他线程执行的，并没有开启新线程。

4.1.2）使用子类 NSBlockOperation

/**
* 使用子类 NSBlockOperation
*/
- (void)useBlockOperation {
    // 1.创建 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    // 2.调用 start 方法开始执行操作
    [op start];
}

运行结果


image.png


注意：和上边 NSInvocationOperation 使用一样。因为代码是在主线程中调用的，所以打印结果为主线程。如果在其他线程中执行操作，则打印结果为其他线程。

但是，NSBlockOperation 还提供了一个方法 addExecutionBlock:，通过 addExecutionBlock: 就可以为 NSBlockOperation 添加额外的操作。这些操作（包括 blockOperationWithBlock 中的操作）可以在不同的线程中同时（并发）执行。只有当所有相关的操作已经完成执行时，才视为完成。

如果添加的操作多的话，blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行，这是由系统决定的，并不是说添加到 blockOperationWithBlock: 中的操作一定会在当前线程中执行。（可以使用 addExecutionBlock: 多添加几个操作试试）。

/**
 * 使用子类 NSBlockOperation
 * 调用方法 AddExecutionBlock:
*/
- (void)useBlockOperationAddExecutionBlock {
    // 1.创建 NSBlockOperation 对象
    NSBlockOperation *op = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"1---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    // 2.添加额外的操作
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"2---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"5---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"6---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"7---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"8---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    // 3.调用 start 方法开始执行操作
    [op start];
}

运行结果


image.png


可以看出：使用子类 NSBlockOperation，并调用方法 AddExecutionBlock: 的情况下，blockOperationWithBlock:方法中的操作 和 addExecutionBlock: 中的操作是在不同的线程中异步执行的。而且，这次执行结果中 blockOperationWithBlock:方法中的操作也不是在当前线程（主线程）中执行的。从而印证了blockOperationWithBlock: 中的操作也可能会在其他线程（非当前线程）中执行。

一般情况下，如果一个 NSBlockOperation 对象封装了多个操作。NSBlockOperation 是否开启新线程，取决于操作的个数。如果添加的操作的个数多，就会自动开启新线程。当然开启的线程数是由系统来决定的。

4.1.3）使用自定义继承自 NSOperation 的子类

如果使用子类 NSInvocationOperation、NSBlockOperation 不能满足日常需求，我们可以使用自定义继承自 NSOperation 的子类。可以通过重写 main 或者 start 方法 来定义自己的 NSOperation 对象。重写main方法比较简单，我们不需要管理操作的状态属性 isExecuting 和 isFinished。当 main 执行完返回的时候，这个操作就结束了。

先定义一个继承自 NSOperation 的子类，重写main方法。



image.png


CustomOperation.h

#import <Foundation/Foundation.h>
@interface CustomOperation : NSOperation
@end

CustomOperation.m

#import "CustomOperation.h"
@implementation CustomOperation
- (void)main {
    if (!self.isCancelled) {
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2];
            NSLog(@"1---%@", [NSThread currentThread]);
        }
    }
}
@end

使用示例

/**
* 使用自定义继承自 NSOperation 的子类
*/
- (void)useCustomOperation {
    // 1.创建 YSCOperation 对象
    CustomOperation *op = [[CustomOperation alloc] init];
    // 2.调用 start 方法开始执行操作
    [op start];
}

可以看出：在没有使用 NSOperationQueue、在主线程单独使用自定义继承自 NSOperation 的子类的情况下，是在主线程执行操作，并没有开启新线程。

4.2）创建队列

NSOperationQueue 一共有两种队列：主队列、自定义队列。其中自定义队列同时包含了串行、并发功能。下边是主队列、自定义队列的基本创建方法和特点。

  • 主队列

凡是添加到主队列中的操作，都会放到主线程中执行。

// 主队列获取方法
NSOperationQueue *queue = [NSOperationQueue mainQueue];
  • 自定义队列（非主队列）

添加到这种队列中的操作，就会自动放到子线程中执行（同时包含了：串行、并发功能）

// 自定义队列创建方法
NSOperationQueue *queue = [[NSOperationQueue alloc] init];

4.3）将操作加入到队列中

上边我们说到 NSOperation 需要配合 NSOperationQueue 来实现多线程。

那么我们需要将创建好的操作加入到队列中去。总共有两种方法：

  • 1.-(void)addOperation:(NSOperation *)op; 需要先创建操作，再将创建好的操作加入到创建好的队列中去。
/**
* 使用 addOperation: 将操作加入到操作队列中
*/
- (void)addOperationToQueue {
    // 1.创建队列
    NSOperationQueue *queue = [[NSOperationQueue alloc] init];
    // 2.创建操作
    // 使用 NSInvocationOperation 创建操作1
    NSInvocationOperation *op1 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task1) object:nil];
    // 使用 NSInvocationOperation 创建操作2
    NSInvocationOperation *op2 = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(task2) object:nil];
    // 使用 NSBlockOperation 创建操作3
    NSBlockOperation *op3 = [NSBlockOperation blockOperationWithBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"3---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    [op3 addExecutionBlock:^{
        for (int i = 0; i < 2; i++) {
            [NSThread sleepForTimeInterval:2]; // 模拟耗时操作
            NSLog(@"4---%@", [NSThread currentThread]); // 打印当前线程
        }
    }];
    // 3.使用 addOperation: 添加所有操作到队列中
    [queue addOperation:op1]; // [op1 start]
    [queue addOperation:op2]; // [op2 start]
    [queue addOperation:op3]; // [op3 start]
}

运行结果


image.png

可以看出：使用 NSOperation 子类创建操作，并使用 addOperation: 将操作加入到操作队列后能够开启新线程，进行并发执行。

文章标签：
iOS开发
调度
关键词：
iOS thread
iOS principle
iOS principle thread
WhatsXie
目录
相关文章
anny_4243
|
存储 监控 网络协议
iOS 友盟崩溃日志分析——Thread state
iOS 友盟崩溃日志分析——Thread state
anny_4243
601 0
WhatsXie
|
iOS开发
iOS Principle：CGAffineTransform
iOS Principle：CGAffineTransform
WhatsXie
183 0
iOS Principle：CGAffineTransform
WhatsXie
|
安全 Unix API
iOS Principle：CALayer（下）
iOS Principle：CALayer（下）
WhatsXie
173 0
iOS Principle：CALayer（下）
WhatsXie
|
iOS开发
iOS Principle：CALayer（中）
iOS Principle：CALayer（中）
WhatsXie
151 0
iOS Principle：CALayer（中）
WhatsXie
|
API C语言 iOS开发
iOS Principle：CALayer（上）
iOS Principle：CALayer（上）
WhatsXie
180 0
iOS Principle：CALayer（上）
WhatsXie
|
存储 缓存 iOS开发
iOS Principle：weak
iOS Principle：weak
WhatsXie
170 0
iOS Principle：weak
WhatsXie
|
存储 iOS开发
iOS Principle：Notification（下）
iOS Principle：Notification（下）
WhatsXie
119 0
iOS Principle：Notification（下）
WhatsXie
|
设计模式 iOS开发
iOS Principle：Notification（上）
iOS Principle：Notification（上）
WhatsXie
133 0
iOS Principle：Notification（上）
WhatsXie
|
Web App开发 JSON 移动开发
iOS Principle：ReactNative（下）
iOS Principle：ReactNative（下）
WhatsXie
185 0
iOS Principle：ReactNative（下）
WhatsXie
|
移动开发 前端开发 JavaScript
iOS Principle：ReactNative（中）
iOS Principle：ReactNative（中）
WhatsXie
126 0
iOS Principle：ReactNative（中）