实例方法可直接调用超类的实例方法_Effective Objective-C 2.0 编写高质量iOS与OS X代码的52个有效方法下...

于 2020-12-06 19:32:54 发布
阅读量534 收藏
点赞数
文章标签： 实例方法可直接调用超类的实例方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39878855/article/details/111334789
版权

1ecee9bcc74d5050dcafc7898b6212b8.png

第5章 内存管理

在Objective-C这种面向对象语言里，内存管理是个重要概念。要想用一门语言写出内存使用效率高而且又没有bug的代码，就得掌握其内存管理模型的种种细节。

一旦理解了这些规则，你就会发现，其实Objective-C的内存管理没那么复杂，而且有了“自动引用计数”（Automatic Reference Counting，ARC）之后，就变得更为简单了。ARC几乎把所有内存管理事宜都交由编译器来决定，开发者只需专注于业务逻辑。

第29条：理解引用计数

autorelease会稍后释放对象，从而给调用者留下了足够长的时间，使其可以在需要时先保留返回值。换句话说，此方法可以保证对象在跨越“方法调用边界”（method call boundary）后一定存活。实际上，释放操作会在清空最外层的自动释放池时执行，除非你自己的自动释放池，否则这个时机的就是当前线程的下一次事件循环。

要点

  1. 引用计数机制通过可以递增递减的计数器来管理内存。对象创建好之后，其保留计数至少为1.若保留计数为正，则对象继续存活。当保留计数将为0时，对象就被销毁了。
  2. 在对象生命期中，其余对象通过引用来保留或释放此对象。保留与释放操作分别会递增及递减保留计数。

第30条：以ARC简化引用计数

若方法名以下列词语开头，则其返回的对象归调用者所有：

  • alloc
  • new
  • copy
  • mutableCopy

归调用者所有的意思是：调用上述四种方法的那段代码要负责释放方法所返回的对象。也就是说，这些对象的保留计数是正值，而调用了这四种方法的那段代码要将其中一次保留操作抵消掉。如果还有其他对象保留此对象，并对其调用了autorelease，并对其调用了autorelease，那么保留计数的值可能比1大，这也是retainCount方法不大有用的原因之一。

若方法名不以上述 四个词语开头，则表示其返回的对象并不归调用者所有。在这种情况下，返回的对象会自动释放，所以其值在跨越方法调用边界后依然有效。要想使对象多存活一段时间，必须令调用者保留它才行。

+ (EOCPerson *)newPerson {
    EOCPerson *person = [[EOCPerson alloc] init];
    return person;
    /**
     * The method name begins with 'new',and since 'person'
     * already has an unbalanced + 1 retain count from the 
     * 'alloc', no retains, releases, or autoreleases are 
     * required when returning.
     */
}

+ (EOCPerson *)somePerson {
    EOCPerson *person = [[EOCPerson alloc] init];
    return person;
    /** 
     * The method name does not begin with one of the 'owning'
     * prefixes, therefore ARC will add an autorelease when
     * returning 'person'.
     * The equivalent manual reference counting statement is:
     *     return [person autorelease];
     */
}

- (void)doSomething {
    EOCPerson *personOne = [EOCPerson newPerson];
    // ...
   
    EOCPerson *personTwo = [EOCPerson somePerson];
    // ...

    /**
     * At this point, 'personOne' and 'personTwo' go out of 
     * scope, therefore ARC needs to clean them up as required.
     * - 'personOne' was returned as owned by this block of 
     * code, so it needs to be released.
     * - 'personTwo' was returned not owned by this block of 
     * code, so it does not need to be released.
     * The equivalent manual reference counting cleanup code 
     * is:
     *    [personOne release];
     */
}

除了会自动调用“保留”与“释放”方法外，使用ARC还有其他好处，它可以执行一些手工操作很难甚至无法完成的优化。例如，在编译期，ARC会把能够相互抵消的retain，release，autorelease操作简约。如果发现在同一个对象上执行了多次“保留”与“释放”操作，那么ARC有时可以成对地移除这两个操作。

_myPerson  = [EOCPerson personWithName:@"Bob Smith"];
//等价于手动
EOCPerson *tmp = [EOCPerson personWithName:@"Bob Smith"];
_myPerson = [tmp retain];

此时应该能看出来，“personWithName：”方法里的autorelease与上段代码中的retain都是多余的。为提升性能，可将二者删去。但是，在ARC环境下编译代码时，必须考虑“向后兼容性”（backward compatibility），以兼容那些不使用ARC的代码。其实本来ARC也可以直接舍弃autorelease这个概念，并且规定，所有从方法中返回的对象其保留计数都比期望值多1.但是，这样做就破坏了向后兼容性。

下面这段代码演示了ARC是如何通过这些特殊函数来优化程序的：

//Within EOCPerson class 
+ (EOCPerson *)personWithName:(NSString *)name {
    EOCPerson *person = [[EOCPerson alloc] init];
    person.name = name;
    objc_autoreleaseReturnValue(person);
}

// Code using EOCPerson class
EOCPerson *tmp = [EOCPerson personWithName:@"Matt Galloway"];
_myPerson = objc_retainAutoreleaseReturnValue(tmp);

id objc_autoreleaseReturnValue(id object) {
    if ( /* caller will retain object */ ) {
        set_flag(object);
        return object; ///< No autorelease
    } else {
        return [object autorelease];
    }
}

id objc_retainAutoreleaseReturnValue(id object) {
    if (get_flag(object)) {
        clear_flag(object);
        return object; ///< No retain
    } else {
        return [object retain];
    }
}

变量的内存管理语义

  • __strong: 默认语义，保留此值。
  • __unsafe_unretained: 不保留此值，这么做可能不安全，因为等到再次使用变量时，其对象可能已经回收了。
  • __weak: 不保留此值，但是变量可以安全使用，因为如果系统把这个对象回收了，那么变量也会自动清空。
  • __autoreleasing: 把对象“按引用传递”（pass by reference）给方法时，使用这个特殊的修饰符，此值在方法返回时自动释放。

使用__weak局部变量来打破“保留环”：

NSURL *url = [NSURL URLWithString:@"http://..."];
EOCNetworkFetcher *fetcher = [[EOCNetworkFetcher alloc] initWithURL:url];
EOCNetworkFetcher * __weak weakFetcher = fetcher;
[fetcher startWithCompletion:^(BOOL success) { 
    NSLog(@"Finished fetching from %@", weakFetcher.url);
}];

ARC如何清理实例变量

用了ARC之后，就不需要再编写这种dealloc方法了，因为ARC会借用Objective-C++的一项特性来生成清理例程（cleanup routine）。回收Objective-C++对象时，待回收的对象会调用所有C++对象的析构函数（destructor）。编译器如果发现这个对象里含有C++对象，就会生成名为 .cxx_destruct的方法。而ARC则借助此特性，在该方法中生成清理内存所需的代码。

不过，如果有非Objective-C的对象，比如CoreFoundation中的对象或是由malloc()分配在堆中的内存，那么仍然需要清理。然而不需要像原来那样调用超类的dealloc方法。前文说过，在ARC下不能直接调用dealloc。ARC会自动在 .cxx_destruct方法中生成代码并运行此方法，而在生成的代码中会自动调用超类的dealloc方法。ARC环境下，dealloc方法可以像这样来写：

- (void)dealloc { 
    CFRelease(_coreFoundationObject);
    free(_heapAllocatedMemoryBlob);
}

因为ARC会自动生成回收对象时所执行的代码，所以通常无需再编写dealloc方法。这能减少项目源代码的大小，而且可以省去其中一些样板代码（boilerplate code）。

要点

  1. 有ARC之后，程序员就无需担心内存管理问题了。使用ARC来编程，可省去类中的许多“样板代码”。
  2. ARC管理对象生命期的办法基本上就是：在合适的地方接入“保留”及“释放”操作。在ARC环境下，变量的内存管理语义可以通过修饰符指明，而原来则需要手工执行“保留”及“释放”操作。
  3. 由方法所返回的对象，其内存管理语义总是通过方法名来体现。ARC将此确定为开发者必须遵守的规则。
  4. ARC只负责管理Objective-C对象的内存。尤其要注意：CoreFoundation对象不归ARC管理，开发者必须适时调用CFRetain/CFRelease。

第31条：在dealloc方法中只释放引用并解除监听

 - (void)dealloc {
    CFRelease(coreFoundationObject);
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}
#import <Foundation/Foundation.h>

@interface EOCServerConnection : NSObject
- (void)open:(NSString *)address;
- (void)close;
@end

要点

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

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

EOCSomeClass *object;
@try {
    object = [[EOCSomeClass alloc] init];
    [object doSomethingThatMayThrow];
}
@catch (...) {
    NSLog(@"Whoops, there was an error. ");
}
@finally {
    [object release];
}

如果手工管理引用计数，而且必须捕获异常，那么要设法保证所编代码能把对象正确清理干净。若使用ARC且必须捕获异常，则需打开编译器的-fobjc-arc-exceptions标志。但最重要的是：在发现大量异常捕获操作时，应考虑重构代码，用NSError式错误信息传递法来取代异常。

要点

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

第33条：以弱引用避免保留环

要点

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

第34条：以“自动释放池块”降低内存峰值

NSArray *databaseRecords = /* ... */;
NSMutableArray *people = [NSMutableArray new];
for [NSDictionary *record in databaseRecords) {
    EOCPerson *person = [[EOCPerson alloc] initWithRecord:record];
    [people addObject:person];
}

EOCPerson的初始化函数也许会像上例那样，再创建出一些临时对象。若记录有很多条，则内存中也会有很多不必要的临时对象，它们本来应该提早回收的。增加一个自动释放池即可解决此问题。如果把循环内的代码包裹在“自动释放池”中，那么在循环中自动释放的对象就会放在这个池，而不是线程的主池里面。例如：

NSArray *databaseRecords = /* ... */;
NSMutableArray *people = [NSMutableArray new];
for [NSDictionary *record in databaseRecords) {
    @autoreleasepool {
        EOCPerson *person = [[EOCPerson alloc] initWithRecord:record];
        [people addObject:person];
    }
}

加上这个自动释放池之后，应用程序在执行循环时的内存峰值就会降低，不再像原来那么高了。内存峰值（high-memory waterline）是指应用程序在某些特定时段内的最大内存用量（highest memory footprint）。新增的自动释放池块可以减少这个峰值，应为系统会在块的末尾把某些对象回收掉。而刚才提到的那些临时对象，就在回收之列。

要点

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

第35条：用“僵尸对象”调试内存管理问题

# Obtain the class of the object being deallocated
Class cls = object_getClass(self);

//Get the class's name
const char *clsName = class_getName(cls);

//Prepend _NSZombie_ to the class name
const char *zombieClsName = "_NSZombie_" + clsName;

// See if the specific zombie class exists
Class zombieCls = objc_lookUpClass(zombieClsName);

// If the specific zombie class doesn't exist,
// then it needs to be created
if (!zombieCls) {
    // Obtain the template zombie class called _NSZombie_
    Class baseZombieCls = objc_lookUpClass("_NSZombie_");
    
    //Duplicate the base zombie class, where the new class's 
    // name is the prepended string from above
    zombieCls = objc_duplicatedClass(baseZombieCls,
                                     zombieClsName, 0);
}

//Perform normal destruction of the object being deallocated
objc_destructInstance(self);

// Set the class of the object being deallocated
// to the zombie class
objc_setClass(self, zombieCls);

//The class of 'self' is now _NSZombie_OriginalClass
//Obtain the object's class
Class cls = object_getClass(self);

//Get the class's name
const char *clsName = class_getName(cls);

// Check if the class is prefixed with _NSZombie_
if (string_has_prefix(clsName, *_NSZombie_") {
    // If so, this object is a zombie

    // Get the original class name by akipping past the 
    // _NSZombie_, i.e. taking the substring from character 10
    const char *originalClsName = substring_from(clsName, 10);

    // Get the selector name of the message
    const char *selectorName = sel_getName(_cmd);

    // Log a message to indicate which selector is
    // being sent to which zombie
    Log("*** -[%s %s], message sent to deallocated instance %p",
        originalClsName, selectorName, self);

    // Kill the application
    abort();
}

要点

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

第36条：不要使用retainCount

要点

  1. 对象的保留计数看似有用，实则不然，因为任何给定时间点上的“绝对保留计数”（absolute retain count）都无法反应对象生命期的全貌。
  2. 引入ARC之后，retainCount方法就正式废止了，在ARC下调用该方法会导致编译器报错。

第6章：块与大中枢派发

当前多线程编程的核心就是“块”（block）与“大中枢派发”（Grand Central dispatch，GCD）。这虽然是两种不同的技术，但他们是一并引入的。“块”是一种可在C，C++及Objective-C代码中使用的“词法闭包”（lexical closure），它极为有用，这主要是因为借由此机制，在定义“块”的范围内，它可以访问到其中的全部变量。

GCD是一种块有关的技术，它提供了对线程的抽象，而这种抽象则基于“派发队列”（dispatch queue）。开发者可将块排入队列中，由GCD负责处理所有调度事宜。GCD会根据系统资源情况，适时地创建，复用，摧毁后台线程（background thread），以便处理每个队列。此外，使用GCD还可以方便地完成常见编程任务，比如编写“只执行一次的线程安全代码”（thread-safe single-code excution），或者根据可用的系统资源来并发执行多个操作。

块与CGD都是当前Objective-C编程的基石。因此，必须理解其工作原理及功能。

第37条：理解“块”这一概念

0a623c85d4ecd2f851771469a1b0d0a2.png 
int (^addBlock)(int a, int b) = ^(int a, int b) {
    return a + b;
};

要点

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

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

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

=>

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

要点

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

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

#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;

EOCNetworkFetcher *fetcher =
    [[EOCNetworkFetcher alloc] initWithURL:url];
[fetcher startWithCompletionHander:^(NSData *data) {
        //Handle success
    }
    failureHandler:^(NSError *error) {
}];
#import <Foundation/Foundation.h>

@class EOCNetworkFetcher;
typedef void(^EOCNetworkFetcherCompletionHandler)
                              (NSData *data, NSError *error);

@interface EOCNetworkFetcher : NSObject
- (id)initWithURL:(NSURL *)url;
- (void)startWithCompletionHandler:
              (EOCNetworkFetcherCompletionHandler)completion;

EOCNetworkFetcher *fetcher =
    [[EOCNetworkFetcher alloc] initWithURL:url];
[fetcher startWithCompletionHander:^(NSData *data, NSError *error) {
    if (error) {
        //Handle failure
    } else {
        //Handle success
    }
}];

笔者建议使用同一个块来处理成功与失败情况。

有时需要在相关时间点执行回掉操作，这种情况下也可以使用handler块。

typedef void(^EOCNetworkFetcherProgressHandler)(float progress);

@property (nonatomic, copy)EOCNetworkFetcherProgressHandler progressHandler;

要求

  1. 在创建对象时，可以使用内联的handler块相关业务逻辑一并声明。
  2. 在有多个实例需要监控时，如果采用委托模式，那么经常需要根据传入的对象来切换，而若改用handler块来实现，则可直接将块与相关对象放在一起。
  3. 设计API时如果用到了handler块，那么可以增加一个参数，使调用者可通过此参数来决定应该把块安排在哪个队列上执行。

第40条：用块引用其所需对象时不要出现保留环

- （void)p_requestCompleted {
    if (_completionHandler) {
        _completionHandler(_downloadData);
    }
    self.completionHandler = nil;
}

要点

  1. 如果块所捕获的对象直接或间接地保留了块本身，那么就得当心保留环问题。
  2. 一定要找个适当的时机解除保留环，而不能把责任推给API的调用者。

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

_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;
    });
}

然而还可以继续进一步优化。设置方法并不一定非得是同步的。设置实例变量所用的块，并不需要向设置方法返回什么值。也就是说，设置方法的代码可以改成下面这样：

- (void)setSomeString:(NSString *)someString {
    dispatch_async(_syncQueue, ^{
        _someString = someString;
    });
}

这次只是把同步派发改成了异步派发，从调用者的角度来看，这个小改动可以提升设置方法的执行速度，而读取操作与写入操作依然会按顺序执行。但这么该有个坏处，如果你测一下程序性能，那么可能会发现这种写法比原来慢，因为执行异步派发时，需要拷贝块。若拷贝块所用的时间明显超过执行块所花的时间，则这种做法将比原来更慢。由于本书所举的这个例子很简单，所以改完之后很可能会变慢。然而，若是派发给队列的块要执行更为繁重的任务，那么仍然可以考虑这种备选方案。

_syncQueue = dispatch_get_global_queue(DISPATCH_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;
    });
}

e743a0ee9770bcc32174c06d8d8e53d2.png

要点

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

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

[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 performSelectorOnMainThread:@selector(doSomething)
                       withObject:nil
                    waitUntilDone:NO];

=>

dispatch_async(dispatch_get_main_queue(), ^{
    [self doSomething];
});

要点

  1. performSelector系列方法在内存管理方面容易有疏失。它无法确定将要执行的选择器具体是什么，因而ARC编译器也就无法插入适当的内存管理方法。
  2. performSelector系列方法所能处理的选择器太过局限了，选择器的返回值类型及发送给方法的参数个数都受到了限制。
  3. 如果想把任务放在另一个线程上执行，那么最好不要用performSelector系列方法，而是应该把任务封装到块里，然后调用大中枢派发机制的相关方法来实现。

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

  1. 使用NSOperation及NSOperationQueue的好处如下：
  2. 取消某个操作。
  3. 制定操作间的依赖关系。
  4. 通过简直观测机制（简称KVO）来监听，比如可以通过isCancelled属性来判断任务是否以取消，又比如可以通过isFinished属性来判断任务是否以完成。
  5. 指定操作的优先级。

要点

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

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

dispatch_queue_t queue = 
    dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_t dispatchGroup = dispatch_group_create();
for (id object in collection) {
    dispatch_group_async(dispatchGroup,
                         queue,
                         ^{ [object performTask]; });
}

dispatch_group_wait(dispatchGroup, DESPATCH_TIME_FOREVER);
//continue processing after completing tasks

若当前线程不应阻塞，则可用notify函数来取代wait：

dispatch_queue_t notifyQueue = dispatch_get_main_queue();
dispatch_group_notify(dispatchGroup,
                      notifyQueue,
                      ^{
                       //Continue processing after completing tasks
                       });

要点

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

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

+ (id)sharedInstance {
    static EOCClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once($onceToken, ^{
        shareInstance = [[self class] init];
    });
    return sharedInstance;
}

要点

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

第46条：不要使用dispatch_get_current_queue

要点

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

第7章 系统框架

系统框架很强大，不过它是经历多年研发才成了今天这个样子的。因此，里面也许会有不合时宜而且用起来很蹩脚的地方，但也会有遗失的珍宝藏于其间。

第47条：熟悉系统框架

除了Foundation与CoreFoundation之外，还有很多系统库，其中包括但不限于下面列出的这些：

  • CFNetwork 此框架提供了C语言级别的网络通信能力，它将“BSD套接字”（BSD socket）抽象成易于使用的网络接口。而Foundation则将该框架里的部分内容封装为Objective-C语言的接口，以便进行网络通信，例如可以用NSURLConnection从URL中下载数据。
  • CoreAudio 该框架所提供的C语言API可用来操作设备上的音频硬件。这个框架属于比较难用的那种，因为音频处理本身就很复杂。所幸由这套API可以抽象出另外一套Objective-C式API，用后者来处理音频问题会更简单些。
  • AVFoundation 此框架所提供的Objective-C接口可将对象放入数据库，便于持久保存。CoreData会处理数据的获取及存储事宜，而且可以跨越Mac OS X及iOS平台。
  • CoreText 此框架提供的C语言接口可以高效执行文字排版及渲染操作。

在UI框架下有

  • CoreAnimation是用Objective-C语言写成的。它提供了一些工具，而UI框架则用这些工具来渲染图形并播放动画。开发者编程时可能从来不会深入到这种级别，不过知道该框架总是好的。CoreAnimation本身并不是框架，它是QuartzCore框架的一部分。然而在框架的国度里，CoreAnimation仍应算作“一等公民”（first-class critizen）。
  • CoreGraphics框架以C语言写成，其中提供了2D渲染所必备的数据结构与函数。例如，其中定义了CGPoint，CGSize，CGRect等数据结构，而UIKit框架中的UIView类在确定视图控制之间的相对位置时，这些数据结构都要用到。

UI框架之上，有MapKit框架，Social框架等。

要点

  1. 许多系统框架都可以直接使用。其中最重要的是Foundation与CoreFoundation，这两个框架提供了构建应用程序所需的许多核心功能。
  2. 很多常见任务都能用框架来做，例如音频与视频处理，网络通信，数据管理等。
  3. 请记住：用纯C写成的框架与用Objective-C写成的一样重要，若想成为优秀的Objective-C开发者，应该掌握C语言的核心概念。

第48条：多用块枚举，少用for循环

NSArray *anArray = /* ... */;
[anArray enumerateObjectsUsingBlock:
    ^(id object, NSUInteger idx, BOOL *stop) {
         //Do something with 'object'
         if (shouldStop) {
             *stop = YES;
         }
    }];
NSDictionary *aDictionary = /* ... */;
[aDictionary enumerateKeyAndObjectsUsingBlock:
    ^(id key, id object, BOOL *stop) {
        //Do something with 'key' and 'object'
        if (shouldStop) {
            *stop = YES;
        }
     }];
NSSet *aSet = /* ... */;
[aSet enumerateObjectsUsingBlock:
    ^(id object, BOOL *stop) {
         // Do something with 'object'
         if (shouldStop) {
             *stop = YES;
         }
     }];

要点

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

第49条：对自定义其内存管理语义的collection使用无缝桥接

NSArray *anNSArray = @[@1, @2, @3, @4, @5];
CFArrayRef aCFArray = (__bridge CFArrayRef)anNSArray;
NSLog(@"Size of array = %li", CFArrayGetCount(aCFArray));
//Output: Size of array = 5
CFMutableDictionaryRef CFDictionaryCreateMutable(
     CFAllocatorRef allocator,
     CFIndex capacity,
     const CFDictionaryKeyCallBacks *keyCallBacks,
     const CFDictionaryValueCallBacks *valueCallBacks
)

struct CFDictionaryKeyCallBacks {
    CFIndex version;
    CFDictionaryRetainCallBack retain;
    CFDictionaryReleaseCallBack release;
    CFDictionaryCopyDescriptionCallBack copyDescription;
    CFDictionaryEqualCallBack equal;
    CFDictionaryHashCallBack hash;
};

struct CFDictionaryValueCallBacks {
    CFIndex version;
    CFDictionaryRetainCallBack retain;
    CFDictionaryReleaseCallBack release;
    CFDictionaryCopyDescriptionCallBack copyDescription;
    CFDictionaryEqualCallBack equal;
};

typedef const void * (*CFDictionaryRetainCallBack) {
    CFAllocatorRef allocator,
    const void *value
};

const void* CustomCallback(CFAllocatorRef allocator,
                           const void *value)
{
    return value;
}

#import <Foundation/Foundation.h>
#import <CoreFoundation/CoreFoundation.h>

const void* EOCRetainCallback(CFAllocatorRef allocator, 
                              const void *value)
{
    CFRelease(value);
}

CFDictionaryKeyCallBacks keyCallbacks = {
    0, 
    EOCRetainCallback,
    EOCReleaseCallback,
    NULL,
    CFEqual,
    CFHash
};

CFDictionaryValueCallBacks valueCallbacks = {
    0, 
    EOCRetainCallback,
    EOCReleaseCallback,
    NULL,
    CFEqual
};
 
CFMutableDictionaryRef aCFDictionary = 
    CFDictionaryCreateMutable(NULL,
                              0, 
                              &keyCallbacks,
                              &valueCallbacks);
 
NSMutableDictionary *anNSDictionary = 
      (__bridge_transfer NSMutableDictionary *)aCFDictionary;

要点

  1. 通过无缝桥接技术，可以在Foundation框架中的Objective-C对象与CoreFoundation框架中的C语言数据结构之间来回转换。
  2. 在CoreFoundation层面创建collection时，可以指定许多回调函数，这些函数表示此collection应如何处理其元素。然后，可运用无缝桥接技术，将其转换成具备特殊内存管理语义的Objective-C collection。

第50条：构建缓存时选用NSCache而非NSDictionary

#import <Foundation/Foundation.h>

#Network fetcher class
typedef void(^EOCNetworkFetcherCompletionHandler)(NSdata *data);
@interface EOCNetworkFetcher : NSObject
- (id)initWithURL:(NSURL *)url;
- (void)startWithCompletionHandler:
                 (EOCNetworkFetcherCompletionHandler)handler;
@end

//Class that uses the network fetcher and caches results
@interface EOCClass : NSObject
@end 

@implementation EOCClass {
    NSCache *_cache;
}

- (id)init {
    if ((self = [super init])) {
        _cache = [NSCache new];
      
        //Cache a maximum of 100 URLs
        _cache.countLimit = 100;
 
        /**
        * The size in bytes of data is used as the cost,
        * so this sets a cost limit of 5MB.
        */
        _cache.totalCostLimit = 5 * 1024 * 1024;
    }
    return self;
}

- (void)downloadDataForURL:(NSURL *)url {
    NSData *cacheData = [_cache objectForKey:url];
    if (cachedData) {
        //Cache hit
        [self useData:cachedData];
    } else {
        //Cache miss
        EOCNetworkFetcher *fetcher = [[EOCNetworkFetcher alloc] initWithURL:url];
        [fetcher startWithCompletionHandler:^(NSData *data) { 
             [_cache setObject:data forKey:url cost:data.length];
             [self useData:data];
        }];
    }
}
@end
- (void)downloadDataForURL:(NSURL *)url {
    NSPurgeableData *cacheData = [_cache objectForKey:url];
    if (cachedData) {
        //Stop the data being purged
        [cacheData beginContentAccess];

        //Use the cached data
        [self useData:cachedData];

        //Mark that the data my be purged again
        [cacheData endContentAccess];
    } else {
        //Cache miss
        EOCNetworkFetcher *fetcher = [[EOCNetworkFetcher alloc] initWithURL:url];
        [fetcher startWithCompletionHandler:^(NSData *data) {  
             NSPurgeableData *purgeableData = [NSPurgeableData dataWithData:data];
             [_cache setObject:purgeableData forKey:url cost:data.length];
             [self useData:data];

             //Mark that the data my be purged now
             [cacheData endContentAccess];
        }];
    }
}

要点

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

第51条：精简initialize与load的实现代码

initialize方法只应该用来设置内部数据。不应该在其中调用其他方法，即使是本类自己的方法，也最好别调用。因为稍后可能还要给那些方法里添加更多功能，如果在初始化过程中调用它们，那么还是有可能导致刚才说的那个问题。若某个全局状态无法在编译期初始化，则可以放在initialize里来做。下列代码演示了这种用法：

//EOCClass.h
#import <Foundation/Foundation.h>

@interface EOCClass : NSObject
@end

//EOCClass.m
#import "EOCClass.h"

static const int kInterval = 10;
static NSMutableArray *kSomeObjects;

@implementation EOCClass

+ (void)initialize {
    if (self == [EOCClass class]) {
        kSomeObjects = [NSMutableArray new];
    }
}

@end

整数可以在编译期定义，然而可变数组不行，因为它是个Objective-C对象，所以创建实例之前必须先激活运行期系统。注意，某些Objective-C对象也可以在编译期创建，例如NSString实例。然而，创建下面这种对象会令编译器报错。

static NSMutableArray *kSomeObjects = [NSMutableArray new];

要点

  1. 在加载阶段，如果类实现了load方法，那么系统就会调用它。分类里也可以定义此方法，类的load方法要比分类中的先调用。与其他方法不同，load方法不参与覆写机制。
  2. 首次使用某个类之前，系统会向其发送initialize消息。由于此方法准从普通的覆写规则，所以通常应该在里面判断当前要初始化的哪个类。
  3. load与initialize方法都应该实现得精简一些，这有助于保持应用程序的响应能力，也能减少引入“依赖环”（interdependency cycle）的几率。
  4. 无法在编译期设定的全局变量，可以放在initialize方法里初始化。

第52条：别忘了NSTimer会保留其目标对象

#import <Foundation/Foundation.h>

@interface NSTimer (EOCBlocksSupport)

+ (NSTimer*)eoc_scheduledTimerWithTimerInterval:(NSTimeInterval)interval
                                         block:(void(^)())block
                                       repeats:(BOOL)repeats;
@end

@implementation NSTimer (EOCBlocksSupport)

+ (NSTimer*)eoc_scheduledTimerWithTimerInterval:(NSTimeInterval)interval
                                         block:(void(^)())block
                                       repeats:(BOOL)repeats {
    return [self scheduledTimerWithTimeInterval:interval
                                      target:self
                            selector:@selector(eoc_blockInvoke:)
                                userInfo:[block copy]
                                repeats:repeats];
}

+ (void)eoc_blockInvoke:(NSTimer*)timer {
    void (^block)() = timer.userInfo;
    if (block) {
        block();
    }
}

@end


- (void)startPolling {
    __weak EOCClass *weakSelf = self;
    _pollTimer = [NSTimer eoc_scheduledTimerWithTimerInterval:5.0
                                                       block:^{
                                               EOCClass *strongSelf = weakSelf;
                                               [strongSelf p_doPoll];
                                                              }
                                                     repeats:YES];
}

这段代码采用了一种很有效的的写法，它先定义了一个弱引用，令其指向self，然后使块捕获这个引用，而不直接去捕获普通的self变量。也就是说，self不会为计时器所保留。当块开始执行时，立刻生成strong引用，以保证实例在执行期间持续存活。

采用这种写法之后，如果外界指向EOCClass实例的最后一个引用将其释放，则该实例就可为系统所回收了。回收过程中还会调用计时器的invalidate方法，这样的话，计时器就不会再执行任务了。此处使用weak 引用还能令程序更加安全，因为有时开发者可能在编写dealloc时忘了调用计时器的invalidate方法，从而导致计时器再次运行，若发生此类情况，则块里的weakSelf会变成nil。

要点

  1. NSTimer对象会保留其目标，知道计时器本身失效为止，调用invalidate方法可令计时器失效，另外，一次性的计时器在触发完任务之后也会失效。
  2. 反复执行任务的计时器（repeating timer），很容易引入保留环，如果这种计时器的目标对象又保留了计时器本身，那肯定会导致保留环。这种环保留关系，可能是直接发生的，也可能是通过对象图里的其他对象间接发生的。
  3. 可以扩充NSTimer的功能，用“块”来打破保留环。不过，除非NSTimer将来在公共接口里提供此功能，否则必须创建分类，将相关实现代码加入其中。
weixin_39878855
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值