当前位置： 首页 > news >正文

EOC第六章《块与中枢派发》

news 2025/7/12 10:38:25

文章目录

    • 第37条：理解block这一概念
    • 第38条：为常用的块类型创建typedef
    • 第39条：用handler块降低代码分散程度
    • 第41条：多用派发队列，少用同步锁
      • 方案一：使用串行同步队列来将读写操作都安排到同一个队列里：
      • 方案二：将写操作放入栅栏快中，让他们单独执行；将读取操作并发执行。
    • 第42条：多用GCD，少用performSelector系列方法
    • 第43条：掌握GCD及操作队列的使用时机
    • 第44条：通过Dispath Group机制，根据系统资源状况来执行任务
    • 第45条：使用dispatch_once来执行只需运行一次的线程安全代码
    • 第46条：不要使用dispatch_get_current_queue

第37条：理解block这一概念

对于“块”的基础知识就不再赘述了，这里强调一下块的种类。

块(Block)分为三类：

  • 栈块
  • 堆块
  • 全局块
  1. 栈block

定义块的时候，其所占内存区域是分配在栈中的，而且只在定义它的那个范围内有效：

void (^block)();if ( /* some condition */ ) {block = ^{NSLog(@"Block A");};} else {block = ^{NSLog(@"Block B");};
}block();

上面定义的两个块只在if else语句范围内有效，一旦离开了最后一个右括号，如果编译器覆写了分配给块的内存，那么就会造成程序崩溃。

  1. 堆block

为了解决这个问题，我们可以给对象发送copy消息，复制一份到堆里，并自带引用计数：

void (^block)();if ( /* some condition */ ) {block = [^{NSLog(@"Block A");} copy];
} else {block = [^{NSLog(@"Block B");} copy];
}block();
  1. 全局block

全局块声明在全局内存里，而不需要在每次用到的时候于栈中创建。

void (^block)() = ^{NSLog(@"This is a block");
};

第38条：为常用的块类型创建typedef

如果我们需要重复创建某种块（相同参数，返回值）的变量，我们就可以通过typedef来给某一种块定义属于它自己的新类型

例如：

int (^variableName)(BOOL flag, int value) =^(BOOL flag, int value){// Implementationreturn someInt;
}

这个块有一个bool参数和一个int参数，并返回int类型。我们可以给它定义类型：

typedef int(^EOCSomeBlock)(BOOL flag, int value);

再次定义的时候，就可以通过简单的赋值来实现：

EOCSomeBlock block = ^(BOOL flag, int value){// Implementation
};

定义作为参数的块：

- (void)startWithCompletionHandler: (void(^)(NSData *data, NSError *error))completion;

这里的块有一个NSData参数，一个NSError参数并没有返回值

typedef void(^EOCCompletionHandler)(NSData *data, NSError *error);
- (void)startWithCompletionHandler:(EOCCompletionHandler)completion;”

通过typedef定义块签名的好处是:如果要某种块增加参数，那么只修改定义签名的那行代码即可。

第39条：用handler块降低代码分散程度

下载网络数据时，如果使用代理方法，会使得代码分布不紧凑，而且如果有多个下载任务的话，还要在回调的代理中判断当前请求的类型。但是如果使用block的话，就可以让网络下载的代码和回调处理的代码写在一起，这样就可以同时解决上面的两个问题：

用代理下载：

- (void)fetchFooData {NSURL *url = [[NSURL alloc] initWithString:@"http://www.example.com/foo.dat"];_fooFetcher = [[EOCNetworkFetcher alloc] initWithURL:url];_fooFetcher.delegate = self;[_fooFetcher start];}- (void)fetchBarData {NSURL *url = [[NSURL alloc] initWithString: @"http://www.example.com/bar.dat"];_barFetcher = [[EOCNetworkFetcher alloc] initWithURL:url];_barFetcher.delegate = self;[_barFetcher start];}- (void)networkFetcher:(EOCNetworkFetcher*)networkFetcher didFinishWithData:(NSData*)data
{   //判断下载器类型if (networkFetcher == _fooFetcher) {_fetchedFooData = data;_fooFetcher = nil;} else if (networkFetcher == _barFetcher) {_fetchedBarData = data;_barFetcher = nil;}
}

用block下载：

- (void)fetchFooData {NSURL *url = [[NSURL alloc] initWithString:@"http://www.example.com/foo.dat"];EOCNetworkFetcher *fetcher =[[EOCNetworkFetcher alloc] initWithURL:url];[fetcher startWithCompletionHandler:^(NSData *data){_fetchedFooData = data;}];}- (void)fetchBarData {NSURL *url = [[NSURL alloc] initWithString: @"http://www.example.com/bar.dat"];EOCNetworkFetcher *fetcher =[[EOCNetworkFetcher alloc] initWithURL:url];[fetcher startWithCompletionHandler:^(NSData *data){_fetchedBarData = data;}];}

还可以将处理成功的代码放在一个块里，处理失败的代码放在另一个块中：

“#import <Foundation/Foundation.h>@class EOCNetworkFetcher;
typedef void(^EOCNetworkFetcherCompletionHandler)(NSData *data);
typedef void(^EOCNetworkFetcherErrorHandler)(NSError *error);@interface EOCNetworkFetcher : NSObject- (id)initWithURL:(NSURL*)url;
- (void)startWithCompletionHandler: (EOCNetworkFetcherCompletionHandler)completion failureHandler: (EOCNetworkFetcherErrorHandler)failure;@endEOCNetworkFetcher *fetcher =[[EOCNetworkFetcher alloc] initWithURL:url];
[fetcher startWithCompletionHander:^(NSData *data){// Handle success
}failureHandler:^(NSError *error){// Handle failure
}];

这样写的好处是，我们可以将处理成功和失败的代码分开来写，看上去更加清晰。
我们还可以将 成功和失败的代码都放在同一个块里：

“#import <Foundation/Foundation.h>@class EOCNetworkFetcher;
typedef void(^EOCNetworkFetcherCompletionHandler)(NSData *data, NSError *error);@interface EOCNetworkFetcher : NSObject- (id)initWithURL:(NSURL*)url;
- (void)startWithCompletionHandler:(EOCNetworkFetcherCompletionHandler)completion;@endEOCNetworkFetcher *fetcher =[[EOCNetworkFetcher alloc] initWithURL:url];[fetcher startWithCompletionHander:^(NSData *data, NSError *error){if (error) {// Handle failure} else {// Handle success}
}];

这样做的好处是，如果及时下载失败或中断了，我们仍然可以取到当前所下载的data。而且，如果在需求上指出：下载成功后得到的数据很少，也视为失败，那么单一块的写法就很适用，因为它可以取得数据后（成功）再判断其是否是下载成功的。
第40条：用块引用其所属对象时不要出现保留环

如果块捕获的对象直接或间接地保留了块本身，那么就需要小心保留环问题:

@implementation EOCClass {EOCNetworkFetcher *_networkFetcher;NSData *_fetchedData;}- (void)downloadData {NSURL *url = [[NSURL alloc] initWithString:@"http://www.example.com/something.dat"];_networkFetcher =[[EOCNetworkFetcher alloc] initWithURL:url];[_networkFetcher startWithCompletionHandler:^(NSData *data){NSLog(@"Request URL %@ finished", _networkFetcher.url);_fetchedData = data;}];}

在这里出现了保留环：块要设置_fetchedData变量，就需要捕获self变量。而self（EOCClass实例）通过实例变量保留了获取器_networkFetcher，而_networkFetcher又保留了块。

解决方案是：在块中取得了data后，将_networkFetcher设为nil。


- (void)downloadData {NSURL *url = [[NSURL alloc] initWithString:@"http://www.example.com/something.dat"];_networkFetcher =[[EOCNetworkFetcher alloc] initWithURL:url];[_networkFetcher startWithCompletionHandler:^(NSData *data){NSLog(@"Request URL %@ finished", _networkFetcher.url);_fetchedData = data;_networkFetcher = nil;}];}

第41条：多用派发队列，少用同步锁

多个线程执行同一份代码时，很可能会造成数据不同步。作者建议使用GCD来为代码加锁的方式解决这个问题。

方案一：使用串行同步队列来将读写操作都安排到同一个队列里：

_syncQueue = dispatch_queue_create("com.effectiveobjectivec.syncQueue", NULL);//读取字符串
- (NSString*)someString {__block NSString *localSomeString;dispatch_sync(_syncQueue, ^{localSomeString = _someString;});return localSomeString;}//设置字符串
- (void)setSomeString:(NSString*)someString {dispatch_sync(_syncQueue, ^{_someString = someString;});
}

这样一来，读写操作都在串行队列进行，就不容易出错。

但是，还有一种方法可以让性能更高：

方案二：将写操作放入栅栏快中，让他们单独执行；将读取操作并发执行。

_syncQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);//读取字符串
- (NSString*)someString {__block NSString *localSomeString;dispatch_sync(_syncQueue, ^{localSomeString = _someString;});return localSomeString;
}
//设置字符串
- (void)setSomeString:(NSString*)someString {dispatch_barrier_async(_syncQueue, ^{_someString = someString;});}

显然，数据的正确性主要取决于写入操作，那么只要保证写入时，线程是安全的，那么即便读取操作是并发的，也可以保证数据是同步的。

这里的dispatch_barrier_async方法使得操作放在了同步队列里“有序进行”，保证了写入操作的任务是在串行队列里。

第42条：多用GCD，少用performSelector系列方法

在iOS开发中，有时会使用performSelector来执行某个方法，但是performSelector系列的方法能处理的选择子很局限：

它无法处理带有多个参数的选择子。
返回值只能是void或者对象类型。
但是如果将方法放在块中，通过GCD来操作就能很好地解决这些问题。尤其是我们如果想要让一个任务在另一个线程上执行，最好应该将任务放到块里，交给GCD来实现，而不是通过performSelector方法。

举几个 来比较这两种方案：

  1. 延后执行某个任务的方法：
// 使用 performSelector:withObject:afterDelay:
[self performSelector:@selector(doSomething) withObject:nil afterDelay:5.0];// 使用 dispatch_after
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC));
dispatch_after(time, dispatch_get_main_queue(), ^(void){[self doSomething];
});
  1. 将任务放在主线程执行：
// 使用 performSelectorOnMainThread:withObject:waitUntilDone:
[self performSelectorOnMainThread:@selector(doSomething) withObject:nil waitUntilDone:NO];// 使用 dispatch_async
// (or if waitUntilDone is YES, then dispatch_sync)
dispatch_async(dispatch_get_main_queue(), ^{[self doSomething];
});

注意：
如果waitUntilDone的参数是Yes，那么就对应GCD的dispatch_sync方法。
我们可以看到，使用GCD的方式可以将线程操作代码和方法调用代码写在同一处，一目了然；而且完全不受调用方法的选择子和方法参数个数的限制。

第43条：掌握GCD及操作队列的使用时机

除了GCD，操作队列（NSOperationQueue）也是解决多线程任务管理问题的一个方案。对于不同的环境，我们要采取不同的策略来解决问题：有时候使用GCD好些，有时则是使用操作队列更加合理。

使用NSOperation和NSOperationQueue的优点：

可以取消操作：在运行任务前，可以在NSOperation对象调用cancel方法，标明此任务不需要执行。但是GCD队列是无法取消的，因为它遵循“安排好之后就不管了（fire and forget）”的原则。
可以指定操作间的依赖关系：例如从服务器下载并处理文件的动作可以用操作来表示。而在处理其他文件之前必须先下载“清单文件”。而后续的下载工作，都要依赖于先下载的清单文件这一操作。
监控NSOperation对象的属性：可以通过KVO来监听NSOperation的属性：可以通过isCancelled属性来判断任务是否已取消；通过isFinished属性来判断任务是否已经完成。
可以指定操作的优先级：操作的优先级表示此操作与队列中其他操作之间的优先关系，我们可以指定它。

第44条：通过Dispath Group机制，根据系统资源状况来执行任务

有时需要等待多个并行任务结束的那一刻执行某个任务，这个时候就可以使用dispath group函数来实现这个需求：

通过dispath group函数，可以把并发执行的多个任务合为一组，于是调用者就可以知道这些任务何时才能全部执行完毕。

//一个优先级低的并发队列
dispatch_queue_t lowPriorityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);//一个优先级高的并发队列
dispatch_queue_t highPriorityQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);//创建dispatch_group
dispatch_group_t dispatchGroup = dispatch_group_create();//将优先级低的队列放入dispatch_group
for (id object in lowPriorityObjects) {dispatch_group_async(dispatchGroup,lowPriorityQueue,^{ [object performTask]; });
}//将优先级高的队列放入dispatch_group
for (id object in highPriorityObjects) {dispatch_group_async(dispatchGroup,highPriorityQueue,^{ [object performTask]; });
}//dispatch_group里的任务都结束后调用块中的代码
dispatch_queue_t notifyQueue = dispatch_get_main_queue();
dispatch_group_notify(dispatchGroup,notifyQueue,^{// Continue processing after completing tasks
});

第45条：使用dispatch_once来执行只需运行一次的线程安全代码

有时我们可能只需要将某段代码执行一次，这时可以通过dispatch_once函数来解决。

dispatch_once函数比较重要的使用例子是单例模式：
我们在创建单例模式的实例时，可以使用dispatch_once函数来令初始化代码只执行一次，并且内部是线程安全的。

而且，对于执行一次的block来说，每次调用函数时传入的标记都必须完全相同，通常标记变量声明在static或global作用域里。

  • (id)sharedInstance {

    static EOCClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
     sharedInstance = [[self alloc] init];
    });
    return sharedInstance;
    }
    我们可以这么理解：在dispatch_once块中的代码在程序启动到终止的过程里，只要运行了一次后，就给自己加上了注释符号，不再存在了。

第46条：不要使用dispatch_get_current_queue

我们无法用某个队列来描述“当前队列”这一属性，因为派发队列是按照层级来组织的。

那么什么是队列的层级呢?
在这里插入图片描述

安排在某条队列中的快，会在其上层队列中执行，而层级地位最高的那个队列总是全局并发队列。

在这里，B，C中的块会在A里执行。但是D中的块，可能与A里的块并行，因为A和D的目标队列是并发队列。

正因为有了这种层级关系，所以检查当前队列是并发的还是非并发的就不会总是很准确。

http://www.lryc.cn/news/4499.html

相关文章：

  • 八、Git远程仓库操作——跨团队成员的协作
  • 算法刷题打卡第88天：字母板上的路径
  • UVa The Morning after Halloween 万圣节后的早晨 双向BFS
  • Connext DDS属性配置参考大全（3）
  • Docker-安装Jenkins-使用jenkins发版Java项目
  • spring 中的 Bean 是否线程安全
  • 微电网两阶段鲁棒优化经济调度方法[3]【升级优化版本】（Matlab代码实现）
  • C++入门教程||C++ 数据类型||C++ 变量类型
  • 【visio使用技巧】图片导出pdf时去掉多余空白
  • Rust语言之Option枚举类型
  • 基于TimeQuest时序优化原理和方法
  • LeetCode第332场周赛
  • 2023-2-12刷题情况
  • 拉普拉斯矩阵
  • Top-1错误率、Top-5错误率等常见的模型算法评估指标解析
  • Urho3D 容器类型
  • C语言学习笔记(四): 循环结构程序设计
  • 02 OpenCV图像通道处理
  • 微信小程序图书馆座位预约管理系统
  • 有限元分析学习一
  • android avb2.0 总结
  • 聊天机器人-意图识别类，开源库推荐
  • Java 标识符以及修饰符
  • 封装、继承、Super、重写、多态instanceof类型转换的使用以及个人见解
  • day13_面向对象的三大特征之一（封装）
  • 越界访问数组
  • 软件设计（十）--计算机系统知识
  • 【不知道是啥】浅保存哈
  • 2021 WAIC 世界人工智能大会参会总结
  • ThingsBoard-实现定时任务调度器批量RPC