iOS 常用技术基础

基于 《Effective+Objective-C+2.0++编写高质量iOS与OS+X代码的52个有效方法》，借鉴、搬个砖，然后补个墙

coffee-heart-i.jpg

---

对Objective-C 语言的发展史理解

1980 年代初，布莱德·考克斯(Brad Cox)在其公司 Stepstone 发明 Objective-C。Brad Cox 一直专注软件工程，软件重用性，组建化，这也是 ObjC 里面的核心思想，Brad 当时想打造一门流行的、可移植的 C 语言与 优雅的Smalltalk 的结合体，而 Smalltalk 是消息型语言的鼻祖。

ObjC 是根据 C语言 所衍生出来的语言，继承了 C语言 的特性，是扩充 C语言 的面向对象编程语言。
相较于开始于 1982 年的 C++ ，Obj-C 更是古老。Object-C 和 C++ 在成长过程中，吸收新生语言，同时相互借鉴。
所以在理解 OC 语言上，应该从 C语言 入手，而不是 C++，尤其要掌握 C语言 中的内存模型和指针。

//消息型语言
Object *obj = [Object new];
[obj performWith:parameter1 and:parameter2];
 
//函数型语言
Object *obj = new Object;
obj->preform(parameter1,parameter2);

Objective-C 为 C语言 了添加面向对象特性，是其超集。Objective-C 使用了动态绑定的消息结构，在运行时才会检查对象类，所以也叫运行时动态语言。

---

对xcode的配置理解

• Architectures(指令集)——设置你想支持的指令集
• Valid architectures : 指即将编译的指令集
• arm指令集和i386、x86_64指令集与真机和模拟器的关系
• Build Active Architecture Only : 是否只编译当前适用的指令集。
• iPhone OS Deployment Target：指的是编译出的程序将在哪个系统版本上运行
• bitcode 理解
• search paths 的理解
• ...

---

在类的头文件中尽量少引用其他头文件

虽然，由于 OC 中，#import 即使重复添加头，也不会造成编程错误，但重复的头文件，在运行和后期维护中会造成干扰。

@class MGDeviceModel;

@interface MGLocalManager : NSObject


@property (nonatomic,strong)  MGDeviceModel  *m_deviceModel;

一般来说，应在某个类的头文件中使用向前声明（@class语法）来提及别的类，并在实现文件中引入那些类的头文件。这样做可以降低类之间的耦合。

有时无法使用向前声明，比如要声明某个类遵循一项协议。这种情况下，尽量把“该类遵循某协议”的这条声明移至“class-continutation分类”中。如果不行的话，就把协议单独放在一个头文件中，然后将其引入。

注：“class-continutation 分类”说的就是“扩展”。

个人理解：少引入无用头文件的作用：

• 减少程序编辑时间

• 降低类之间的耦合，使类更清晰，让类的使用者更容易理解

• 有效避免相互引用的问题

• 减少类修改维护代价

个人觉得：代码要简洁而精炼

---

多用字面量语法，少用与之等效的语法

NSNumber *someNumber = @(1);
NSArray *animals = @[@"dog",@"cat",@"mouse",@"badger"];
//取下标操作
NSString *dog = animal[1];
NSDictionary *personData = @{@"firstName":@"shi",@"lastName":@"xueqian",age:@(26)};
NSString *lastName = personData[@"lastName"];
 
//可变数组和字典
[mutableArray replaceObjectAtIndex:1 withObject:@"dog"];
[mutableDictionary setObject:@"xueqian" forKey:@"lastName"];
//可用字面量语法来替换
mutableArray[1] = @"dog";
mutableDictonary[@"lastName"] = @"xueqian";

应该使用字面量语法来创建字符串、数值、数组、字典。与创建此类对象的常规方法相比，这么做更加简明扼要，而且便于修改。
应该通过取下标操作来访问数组下标或字典中的键所对应的元素。
用字面量语法创建数组或者字典时，若值中有nil，则会抛出异常。务必确保值里不含 nil。

---

多用类型常量，少用#define预处理指令

//预处理指令
#define ANIMATION_DURATION 0.3
//常量定义
static const NSTimeInterval kAnimationDuration = 0.3;
 
//全局常量  头文件中  声明
extern NSString *const EOCStringConstant;
//全局常量  实现文件中  定义
NSString *const EOCStringConstant = @"VALUE";

少用预处理指令定义常量。因为这样定义出来的常量不含类型信息，编译器只是会在编译前据此执行查找和替换操作。即使有人重新定义了常量值，编译器也不会产生警告信息，这将导致应用程序中的常量值不一致。
在实现文件中使用 static const 来定义“只在编译单元内可见的常量”。由于此类常量不在全局符号表中，所有无须为其名称加前缀。
在头文件中使用 extern 来声明全局常量，并在相关实现文件中定义其值。这种常量要出现在全局符号表中，所有其名称要加以区隔，通常用与之相关的类名做前缀。

但要注意的是，#define 还可以用来定义方法，因为 #define 定义的方法或者常量，内存分配在栈上面，另外是在程序运行前，预编译在内存中，所以一定程度上，会加快编译速度，也是用内存空间换时间的一种方式。

---

用枚举表示状态、选项、状态码

//普通枚举
typedef NS_ENUM(NSUInteger, EOCConnectionState){
      EOCConnectionStateDisconnected,
      EOCConnectionStateConnecting,
      EOCConnectionStateConnected,
};
//switch语句最好不要加defalut分支
switch(_currentState) {
    case:EOCConnectionStateDisconnected:
        //干活
        break;
    case:EOCConnectionStateConnecting:
        //干活
        break;
    case:EOCConnectionStateConnected:
        //干活
        break;
}
 
//二进制枚举
typedef NS_OPTIONS(NSUInteger, EOCPermittedDirection){
    EOCPermittedDirectionUp       = 1 <<  0,
    EOCPermittedDirectionDown  = 1 <<  1,
    EOCPermittedDirectionLeft     = 1 <<  2,
    EOCPermittedDirectionRight   = 1 <<  3,
}
//二进制枚举使用
EOCPermittedDirection direction = EOCPermittedDirectionUp | EOCPermittedDirectionDown;
if (direction & EOCPermittedDirectionUp){
    //有设置  EOCPermittedDirectionUp
}

应用枚举来表示状态机的状态、传递给方法的选项及状态码等值，给这些值起个易懂的名字 ，这样会让程序易读性增加，统一逻辑，另外方便 switch 语句的调度。应避免用散乱的方式去对这种场景的逻辑处理。
另外，如果把传递给某个方法的选项表示为枚举类型，而多个选项又可同时使用，那么就将各选项的值定义为2的幂，以便通过按位或操作将其组合起来。
swift中，switch 还可以直接匹配字符串，这让这种方式写法变的更有趣。

---

理解“属性”这一概念

Objective-C 对象通常会把其所需要的数据保存为各种实例变量。实例变量一般通过“存取方法”来访问。其中，“获取方法（getter）”用于读取变量值，而“设置方法（setter）”用于写入变量值。

@synthesize语法:编译器会自动创建 get 和 set 方法

@implementation EOCPerson
@synthesize firstName = _myFirstName;
@end

@dynamic关键字：它会告诉编译器，不要自动创建实现属性所用的实例变量，也不要为其创建存取方法。而且，在编译访问属性的代码时，即使编译器发现没有定义存取方法，也不会报错，它相信这些方法能在运行期找到。

@implementation EOCPerson
@dynamic firstName，lastName；
@end

原子性：默认atomic属性。可以通过锁定机制来确保 getter 方法操作的原子性。但是并不能保证“线程安全”。由于iOS中使用同步锁开销太大，一般只使用 nonatomic。

读/写权限：readonly 和 readwrite

getter=：指定getter的方法名。

@property (nonatomic, getter=isOn) BOOL on;

可以使用 @property 语法来定义对象中所封装的数据。
通过“特质”来定义存储数据所需的正确语义。
在设置属性所对应的实例变量时，一定要遵从该属性所声明的语义。
详细请看：iOS属性关键字

---

理解“对象等同性”这一概念

若想检测对象的等同性，请提供“isEqual”和hash方法。
相同的对象必须具有相同的哈希码，但是两个哈希码相同的对象却未必相同。
不要盲目地逐个检测每条属性，而是应该依照具体需求来制定检测方案。
编写 hash 方法时，应该使用计算速度快而且哈希码碰撞概率低的算法。

---

以“类族方式”隐藏实现细节

类族模式可以把实现细节隐藏在一套简单的公共接口后面。
系统框架中经常使用类族。
从类族的公共抽象基类中继承子类时要当心，若有开发文档，则应首先阅读。
类族，也是面向接口编程的体现，这对一个需要长期维护的大型项目，是非常重要的。

---

在既有类中使用关联对象存放自定义数据

关联类型 等效的 @property 属性

OBJC_ASSOCIATION_ASSIGN assign
OBJC_ASSOCIATION_RETAIN_NONATOMIC   nonatomic retain
OBJC_ASSOCIATION_COPY_NONATOMIC nonatomic copy
OBJC_ASSOCIATION_RETAIN retain
OBJC_ASSOCIATION_COPY   copy

//次方法以给定的键和策略为某对象设置关联对象值
void objc_setAssociatedObject(id object, void *key, id value, objc_associationPolicy policy)
//此方法通过给定的键从某对象中获取关联对象的值
void objc_getAssociatedObject(id object, void *key)
//此方法移除某对象的全部关联对象
void objc_removeAssociatedObject(id object)

可以通过“关联对象”机制把两个对象连起来。
定义关联对象时可指定内存管理语义，用以模仿定义属性时所有采用的“拥有关系”和“给拥有关系”。
只有在其他方法不可行时才应选用关联对象，因为这种用法通常会引入难以查找的bug。

---

理解 objc_msgSend 的作用

C语言：C语言使用“静态绑定”，也就是说，在编译期就能决定运行时所调用的函数。
Objective-C：所要调用的函数直到运行期才能确定。在底层，所有方法都是普通的C语言函数，然而对象收到消息之后，究竟该调用哪个方法完全由运行期决定，甚至可以在程序运行时改变，这些特性使得 Objective-C 成为一门真正的动态语言。

//给对象发送消息
id returnValue = [someObject messageName:parameter];
//objc_msgSend原型
void objc_msgSend(id self, SEL _cmd, ...)
//给对象发送消息底层
id returnValue = objc_msgSend(some Object, @selector(messageName:),parameter);

消息由接受者、选择子和参数组成。给某个对象“发送消息”（invoke a message）也就相当于在该对象上“调用方法”(call a method)。
发送给某对象的全部消息都要由“动态消息派发系统”来处理，该系统会查出对应的方法，并执行其代码。

---

理解消息转发机制

1818095-e7a25f32f80550ba.png

OC消息传递机制和消息转发机制

若对象无法响应某个选择子，则进入消息转发流程。
通过运行期的动态方法解析功能，我们可以在需要用到某个方法时再将其加入类中。
对象可以把其无法解读的某些选择子转交给其他对象来处理。
经过上面两步之后，如果还是没办法处理选择子，那就启动完整的消息转发机制。

---

用“方法调配”技术调试“黑盒方法”

//方法交换
void method_exchangeImplementations(Method m1, Method m2)
//方法实现
Method class_getInstanceMethod(Class aClass, SEL aSelector)
 
//demo，交换 lowercaseString 和 uppercaseString 方法
Method originalMethod = class_getInstanceMethod([NSString class],
@selector(lowercaseString));
Method swappedMethod = class_getInstanceMethod([NSString class], @selector(uppercaseString));
method_exchangeImplementations(originalMethod,swappedMethod);

在运行期，可以向类中新增或替换选择子所应用的方法实现。
使用另一份实现来替换原有的方法实现，这道工序叫做“方法调配”（method swizzing），开发者常用此技术向原有实现中添加新功能。
一般来说，只有调试程序的时候才需要在运行期修改方法实现，这种做法不宜滥用。
这种方式，由于所有的类，都会加载 load 方法，所以，可以实现对类默认属性的修改，比如说修改 UILable 的默认字体、UIView 的默认背景等，这个用处还是非常多的，要挖掘。
【iOS 不常用技术解密之 hook】 也有提到这方面的应用

---

第14条：理解“类对象”的用意

1818095-16f3c333126d16f0.png

Class定义

1818095-08172175a478dd08.png

• isMemberOfClass:能够判断出对象是否为某个类的实例
• isKindOfClass：能够判断出对象是否为某类或其派生类的对象

每个实例都有一个指向Class对象的指针，用以表明其类型，而这些Class对象则构成了类的继承体系。
如果对象类型无法在编译期确定，那么就应该使用类型信息查询方法探知。
尽量使用类型信息查询方法来确定对象类型，而不要直接比较类对象，因为某些对象可能实现了消息转发功能。

---

用前缀避免命名空间冲突

Objective-C 没有其他语言那种内置的命名空间机制。鉴于此，我们在起名时需要避免潜在的命名冲突。

避免此问题的唯一办法是变相实现命名空间：为所有名称都加上适当前缀。

选择与你的公司、应用程序或者二者皆有关联之名称作为类名的前缀，并在所有代码中均使用该前缀。
若自己开发的程序库中用到了第三方库，则应为其中的名称加上前缀。

这个是非常重要的，特别是在做 framework 和 library 的封装时，尤为重要

---

实现description方法

- (NSString *)description {
    return [NSString stringWithFormat:@"<%@:%p %@",[self class], self, @{@"firstName":_firstName, @"lastName":_lastName}];
}
 
- (NSString *)description {
      return [NSString stringWithFormat:@"%@ %@",_firstName,_lastName];
}
- (NSString *)debugDescription {
      return [NSStrig stringWithFormat:@"< %@ ,%p  %@ ,%@",[self class], self, _firstName, _lastName];
}

实现 description 方法返回一个有意义的字符串，用以描述该实例。
若想在调试时打印出更详尽的对象描述信息，则应实现 debugDesription 方法。
这其实应该属于编程习惯，就像写一个 shell 时，会加一个 help 方法

---

为私有方法名加前缀

给私有方法的名称加上前缀，这样可以很容易地将其同公共方法区分开，有助于代码维护。
不要单用一个下划线做私有方法的前缀，因为这种做法是预留给苹果公司用的。

---

理解Objective-C错误模型

NSError对象里封装了三条信息：

• Error domain：错误发生的范围，其类型为字符串，通常用一个特有的全局变量来定义。
• Error code：独有的错误代码，其类型为整数。用以知名在某个返回内具体发生了何种错误，常用 enum 来定义。
• User info：用户信息，其类型为字典。有关此错误的额外信息，其中或许包含一段“本地化描述”.

- (BOOL)doSomething:(NSError **)error {
 
if (/*  there was an error  */){
    if (error) {
        *error = [NSError errorWithDomain:domain code:code userInfo:userInfo];
    }
return NO;
else {
return YES;
     }
}
 
NSError *error = nil;
BOOL ret = [object doSomethig:&error];
if (error) {
 
}

只有发生了可使整个应用程序崩溃的严重错误时，才应使用异常。
在错误不那么严重的情况下，可以指派“委托方法”来处理错误，也可以把错误信息放在NSError对象里，经由“输出参数”返回给调用者。

---

理解NSCopying协议

//一个类支持拷贝功能需要实现 NSCopying协议只有这一个方法。其中NSZone目前只有一个默认去，可不管。
- (id)copyWithZone:(NSZone *)zone
 
- （id）copyWithZone:(NSZone *)zone {
    EOCPerson *copy = [[[self class] allocWithZone:zone] initWithFirstName:_firstName andLastName:_lastName];
    return copy;
}

若想令自己所写的对象具有拷贝功能，则需事先 NSCopying 协议。
如果自定义的对象分为可变版本与不可变版本，那么就要同时实现 NSCopying 与 NSMutableCopying 协议。
复制对象时需决定采用浅拷贝还是深拷贝，一般情况下应该尽量 执行浅拷贝。
如果你所写的对象需要深拷贝，那么可考虑新增一个专门执行深拷贝的方法。

---

通过委托与数据源协议进行对象间通信

对象把应对某个行为的责任委托给另外一个类了。

常规的委托模式：信息从类流向受委托者（delegate）。

数据源模式：信息从数据源（Data Source）流向类。

信息流向

委托模式为对象提供了一套接口，使其可由此将相关事件告知其他对象。
将委托对象应该支持的接口定义为协议，在协议中把可能需要处理的事件定义成方法。
当某对象需要从另外一个对象获取数据时，可以使用委托模式。这种情境下，该模式亦称“数据源协议”。
若有必要，可实现含有位段的结构体，将委托对象是否能相应相关协议方法这一信息缓存至其中。

---

将类的实现代码分散到便于管理的数个分类之中

使用分类机制把类的实现代码划分多个管理的小块。
将应该视为“私有”的方法归入名叫Private的分类中，以隐藏实现细节。
以一个分类，实现某个功能，这种方式在 OC 的官方代码中，也是非常常用的方式

---

总是为第三方类名称加前缀

向第三方类中添加分类时，总应给其名称加上你专用的前缀。
向第三方类中添加分类时，总应给其中的方法名加上你专用的前缀。

---

勿在分类中声明属性

把封装数据所用的全部属性都定义在主接口里。
在“class-continuation分类”之外的其他分类中，可以定义存取方法，但尽量不要定义属性。
若是定义了，会非常不好用，只会自己坑自己；当然也有特殊情况，也是需要这种方式的

---

使用“扩展分类”隐藏实现细节

这里的“class-continuation分类”其实就是我们平常所说的“扩展”。

通过“class-continuation分类向类中新增实例变量。
如果某属性在主接口
中声明为“只读”，而类的内部又要用设置方法修改此属性
尽可能的暴露少的接口，方便其他人使用你的类

---

通过协议提供匿名对象

协议可在某种程度上提供匿名类型。具体的对象类型可以淡化成遵从某协议的id类型，协议里规定了对象所对应实现的方法。
使用匿名对象来隐藏类型名称（或类名）。
如果具体类型不重要，重要的是对象能够相应（定义在协议里的）特性方法，那么可以使用匿名对象来表示。

---

在dealloc方法中只释放引用并解除监听

dealloc方法绝不能主动调用。

在dealloc方法里，应该做的事情就是释放指向其他对象的引用，并取消原来订阅的“键值观测”（KVO）或 NSNotificationCenter 等通知，不要做其他事情。
如果对象持有文件描述符等系统资源，那么应该专门编写一个方法来释放此种资源。这样的类要和使用者约定：用完资源后必须调用 close 方法。
执行异步任务的方法不应在 dealloc 里调用；只能在正常状态下执行的那些方法也不应在 dealloc 里调用，因为此时对象已处于正在回收的状态了。

---

编写“异常安全代码”时留意内存管理问题

捕获异常时，一定要注意将 try 块内所创立的对象清理干净。
在默认情况下，ARC 不生成安全处理异常所需的清理代码。开启编译器标志后，可生成这种代码，不过会导致应用程序变大，而且会降低运行效率。

---

以弱引用避免保留环

将某些引用设为 weak，可避免出现“保留环”。
weak 引用可以自动清空，也可以不自动清空。自动清空是随着 ARC 而引入的新特性，由运行期系统来实现。在具备自动清空功能的弱引用上，可以随意读取其数据，因为这种引用不会指向已经回收过的对象。

---

以“自动释放池块”降低内存峰值

iOS系统会自动创建一些线程，这些线程默认都有自动释放池，每次执行“事件循环”（event loop）时，就会将其清空。

自动释放池的范围：左括号到右括号（{自动释放池范围}）。在该范围内的对象，将会在末尾处收到release消息。

自动释放池排布在栈中，对象收到autorelease消息后，系统将其放入最顶端的池里。
合理运用自动释放池，可降低应用程序的内存峰值。
ARC 中，使用@autoreleasepool 这种新式写法能创建出更为轻便的自动释放池。

---

用“僵尸对象”调试内存管理问题

系统在回收对象时，可以不将其真的回收，而是把它转化为僵尸对象。通过环境变量 NSZomebieEnabled 可开启此功能。
系统会修改对象的isa指针，令其指向特殊的僵尸类，从而使该对象变为僵尸对象。僵尸类能够响应所有的选择子，响应方式为：打印一条包含消息内容及其接收者的消息，然后终止应用程序。

理解“ block ”这一概念

//块的语法结构
return_type (^block_name)(parameters)

块的强大之处是：在声明它的范围里，所有变量都可以为其所捕获。也就是说，那个范围内的全部变量，在块里依然可用。

如果块所捕获的变量是对象类型，那么就会自动保留它。

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

为解决此问题，可给块对象发送copy消息以拷贝之。这样的话，就可以把块从栈复制到堆了。

全局块；不会捕捉任何状态（比如外围的变量等），运行时也无须有状态来参与。

块是C、C++、Objective-C中的语法闭包。
块可接受参数，也可返回值。
块可以分配在栈或堆上，也可以是全局的。分配在栈上的块可拷贝到堆里，这样的话，就和标准的 Objective-C 对象一样，具备引用计数了。

为常用的块类型创建 typedef

//块类型的语法结构：
return_type (^block_name)(parameters)
//typedef
typedef return_type(^block_name)(parameters);

以 typedef 重新定义块类型，可令块变量用起来更加简单和代码可读性。
定义新类型时应遵从现有的命名习惯，勿使其名称与别的类型向冲突。
不妨为同一个签名定义多个类型别名。如果要重构的代码使用了块类型的某个别名，那么只需修改相应typedef中的块签名即可，无须改动其他 typedef。

---

用 handler 块降低代码分散程度

委托模式有个缺点：如果累要分别使用多个获取器系在不同数据，那么就得在 delegate 回到方法里根据传入的获取器来切换。

在创建对象时，可以使用内联的 handler 块将相关业务逻辑一并声明。
在有多个实例需要监控时，如果采用委托模式，那么经常需要根据传入的对象来切换，若改用 handler 块来实现，则可直接将块与相关对象放在一起。
设计 API 时如果用到了 handler 块，那么可以增加一个参数，使调用者可通过此参数来决定应该把块安排在哪个队列上执行。
其实在出现 handler 后， 我基本不再使用 delegate 模式，定义可读性都不好；但如果有多个类，使用到同一个 delegate ，这种情况下，delegate 方式会让程序结构更清晰和完善。

---

用块引用其所属对象时不要出现保留环

如果块所捕获的对象直接或间接地保留了块本身，那么就得当心保留环问题。
一定要找个适当的时机解除保留环，而不能把责任推给 API 的调用者。
内存的管理，应当尽量保证在当前类内，虽然这种方式会造成一定程度上的内存开销和使用，但更安全

---

多用派发队列，少用同步锁

派发队列可用来表示同步语义，这种做法要比使用 @synchronized块或NSLock对象更简单。
将同步与异步派发结合起来，可以实现与普通加锁机制一样的同步行为，而这么做却不会阻塞队列执行异步派发的线程。
使用同步队列及栅栏块，可以令同步行为更加高效。

---

多用GCD，少用 performSelector 系列方法

//可以在运行时调用方法
- (id)performSelector:(SEL)selector
//可带一个参数
- (id)performSelector:(SEL)selector withObject:(id)object
//可带两个参数
- (id)performSelector:(SEL)selector withObject:(id)object withObject:(id)object
//可延时执行方法
- (void)performSelector:(SEL)selector withObject:(id)argument afterDelay:(NSTimeInterval)delay
//可放到另一个线程中执行
- (void)performSelector:(SEL)selector onThread:(NSThread *)thread withObject:(id)argument waitUntilDone:(BOOL)wait
- (void)performSelectorOnMainThread:(SEL)selector withObject:(id)argument waitUntilDone:(BOOL)wait
 
//延后执行方法的两种实现方式：
[self performSelector:@selector(doSomething) withObject:nil afterDelay:5.0];
 
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];
});
 
 
//把任务放在主线程执行的两种方式
[self performSlectorOnMainThread:@selector(doSomething) withObject:nil waitUntilDone:NO];
 
dispatch_async(dispatch_get_main_queue(), ^{
    [self doSomething];
});

performSelector 系列方法在内存管理方面容易有疏失。它无法确定将要执行的选择子具体是什么，因而 ARC 编译器也就无法插入适当的内存管理方法。
performSelector 系列方法所能处理的选择子太过局限了，选择子的返回值类型及发送给方法的参数个数都受到限制。
如果想把任务放在另一个线程上执行，那么最好不要用performSelector系列方法，而是应该把任务封装到块里，然后调用GCD的相关方法来实现。
另外，从本身机制上来说，GCD 方式是 纯C 的API，在内存上和调度时间上，都优于 performSelector 的线程调度；所有，在任何时候都应该使用 GCD 实现线程的调度。

---

掌握GCD及操作队列的使用时机

NSOperationQueue 发者可以把操作以 NSOperation 子类的形式放在队列中，而这些操作也能够并发执行。

GCD是 纯C 的 API，而 NSOperationQueue 则是 Objective-C 的对象。

用 NSOperationQueue 类的 “addOerationWithBlock:” 方法搭配 NSBlockOperation 类来使用操作队列，其语法与纯GCD非常类似。

NSOperationQueue与NSOperation类的优点：

• 取消某个操作
• 指定操作间的依赖关系
• 通过KVO监控NSOperation对象的属性
• 指定操作的优先级
• 重用NSOperation对象

在解决多线程与任务管理问题时，派发队列并非唯一方案。
操作队列提供了一套高层的 Objective-C API，能实现纯 GCD 所具备的绝大部分功能，而且还能完成一些更为复杂的操作，那么操作若改用GCD来实现，则需另外编写代码。

---

通过 Dispatch Group机制，根据系统资源状况来执行任务

dispatch group 是 GCD 的一项特性，能够把任务分组。调用者可以等待这组任务执行完毕，也可以在提供回调函数之后继续往下执行，这组任务完成时，调用者会得到通知。

//创建dispatch group
dispatch_group_t dispatch_group_create();
//把任务编组(普通dispatch_async的变体)
void dispatch_group_asunc(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);
//指定任务所属的dispatch_group
void dispatch_group_enter(dispatch_group_t group);
void dispatch_group_leave(dispatch_group_t group);
//等待dispatch_group执行完毕(timeout可以取常量DISPATCH_TIME_FOREVER,表示函数一致等待dispatch_group执行完，而不会超时)
long dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout);
//等待dispatch_group执行完毕之后执行block
void dispatch_group_notify(dispatch_group_t group, dispatch_queue_t queue, dispatch_block_t block);

• 一系列任务可归入一个 dispatch group 之中。开发者可以在这组任务执行完毕时获得通知。
• 通过 dispatch group，可以在并发派发队列里同时执行多项任务。此时 GCD 会根据系统资源状况来调度这些并发执行的任务。 这里若是开发者自己来实现此功能，则需要编写大量代码。

---

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

void dispatch_once (dispatch_once_t *token, dispatch_block_t block);
 
(id)sharedInstance {
static EOCClass )sharedInstance = nil;
static icdispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
   sharedInstance = [[self alloc] init];
});
return sharedInstance;
}

使用 dispatch_once 可以简化代码并且彻底保证线程安全，开发者根本无需担心加锁或同步。

由于每次调用时都必须使用完全相同的标记，所以标记要声明成 static。

把该变量定义在 static 作用域中，可以保证编译器在每次执行 sharedInstance 方法时都会服用这个变量，而不会创建新变量。

经常需要编写“只需执行一次的线程安全代码”。通过 GCD 所提供的 dispatch_once 函数，很容易就能实现此功能。
标记应该声明在 static 或 global 作用域中，这样的话，把只需执行一次的块传给 dispatch_once 函数时，传进去的标记也实现相同的。

---

不要使用 dispatch_get_current_queue

dispatch_get_current_queue 函数的行为常常与开发者所预期的不同。此函数已经废弃，只应做调试之用。
由于派发队列是按层级来组织的，所以无法单用某个队列对象来描述“当前队列”这一概念。
dispatch_get_current_queue 函数用于解决由不可重入的代码所引发的死锁，然而能用此函数解决的问题，通常也能改用“队列特定数据”来解决。

多用块枚举，少用for循环

//for循环遍历
    NSArray *arr1 = @[@1,@2,@3,@4,@5];
    for (int i = 0; i < arr1.count; ++i) {
        NSLog(@"arr1[i]=%@",arr1[i]);
    }
 
    //for循环反向遍历
    for (NSInteger i = arr1.count-1; i >= 0; --i) {
        NSLog(@"arr1[i]=%@",arr1[i]);
    }
 
 //NSEnumerator遍历法
    NSArray *arr1 = @[@1,@2,@3,@4,@5];
    NSEnumerator *enumerator = [arr1 objectEnumerator];
    id object;
    while ((object = [enumerator nextObject]) != nil) {
        NSLog(@"object=%@",object);
    }
 
    //NSEnumerator遍历法反向遍历
    NSEnumerator *reverseenu = [arr1 reverseObjectEnumerator];
    id object1;
    while ((object1 = [reverseenu nextObject]) != nil) {
        NSLog(@"object1=%@",object1);
    }
 
 
    //快速遍历法
    NSArray *arr1 = @[@1,@2,@3,@4,@5];
    for (NSObject *obj in arr1) {
        NSLog(@"obj=%@",obj);
    }
 
    //快速遍历法反向遍历
    for (NSObject *obj1 in [arr1 reverseObjectEnumerator]) {
        NSLog(@"obj1=%@",obj1);
    }
    //块枚举法
    NSArray *arr1 = @[@1,@2,@3,@4,@5];
    [arr1 enumerateObjectsUsingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        NSLog(@"idx=%zd,obj=%@",idx,obj);
    }];
 
    //块枚举法反向遍历
    [arr1 enumerateObjectsWithOptions:NSEnumerationReverse usingBlock:^(id  _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        NSLog(@"idx=%zd,obj=%@",idx,obj);
    }];

遍历 collection 有四种方式。最基本的办法是 for 循环，其次是 NSEnumerator 遍历法及快速遍历法，最新、最先进的方式则是“块枚举法”。
“块枚举法”本身就能通过GCD来并发执行遍历操作，无须另行编写代码。而采用其他遍历方式则无法轻易实现这一点。
若提前知道待遍历的 collection 含有何种对象，则应修改块签名，指出对象的具体类型。

构建缓存时选用NSCache而非 NSDictionary 或者其他类

实现缓存时应选用 NSCache 而非 NSDictionary 对象等。因为 NSCache可以提供优雅的自动删减功能，而且是“线程安全的”，此外，它与字典不同，并不会拷贝键。
可以给 NSCache 对象设置上限，用以限制缓存中的对象总个数及“总成本”，而这些尺度则定义了缓存删减其中对象的时机。但是绝对不要把这些尺度当成可靠的“硬限制”，他们仅对 NSCache 起指导作用。
将 NSPurgeableData 与 NSCache 搭配使用，可实现自动清除数据的功能，也就是说，当 NSPurgeableData 对象所占内存为系统所丢弃时，该对象自身也会从缓存中移除。
如果缓存使用得当，那么应用程序的相应速度就能提高。只有那种“重新计算起来很费事的”数据，才值得放入缓存，比如那些从网络获取或从磁盘读取的数据。