Objective-C中单例模式的实现

单例模式在Cocoa和Cocoa Touch中非常常见。比如这两个，[UIApplication sharedApplication]和[NSApplication sharedApplication]，大家应该都见过。但是我们应该如何在代码中实现一个单例模式呢？

如果你对苹果的文档很熟悉的话，你一定知道，在Cocoa Foundamentals Guide中有一段实现单例模式的示例代码。大致如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

/* Singleton.h */ #import <Foundation/Foundation.h> @interface Singleton : NSObject + (Singleton *)instance; @end /* Singleton.m */ #import "Singleton.h" static Singleton *instance = nil; @implementation Singleton + (Singleton *)instance { if (!instance) { instance = [[super allocWithZone:NULL] init]; } return instance; } + (id)allocWithZone:(NSZone *)zone { return [self instance]; } - (id)copyWithZone:(NSZone *)zone { return self; } - (id)init { if (instance) { return instance; } self = [super init]; return self; } - (id)retain { return self; } - (oneway void)release { // Do nothing } - (id)autorelease { return self; } - (NSUInteger)retainCount { return NSUIntegerMax; } @end

这是一种很标准的Singleton实现，中规中矩。不过这种实现并不是线程安全的。所以各路大神都各显神威，给出了多种单例模式的实现。

Matt Gallagher在博客中放出了一个Macro，用来实现单例模式。虽然是一个宏定义的代码，但是具体实现还是很清楚的。代码如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68

// // SynthesizeSingleton.h // CocoaWithLove // // Created by Matt Gallagher on 20/10/08. // Copyright 2009 Matt Gallagher. All rights reserved. // // Permission is given to use this source code file without charge in any // project, commercial or otherwise, entirely at your risk, with the condition // that any redistribution (in part or whole) of source code must retain // this copyright and permission notice. Attribution in compiled projects is // appreciated but not required. // #define SYNTHESIZE_SINGLETON_FOR_CLASS(classname) static classname *shared##classname = nil; + (classname *)shared##classname { @synchronized(self) { if (shared##classname == nil) { shared##classname = [[self alloc] init]; } } return shared##classname; } + (id)allocWithZone:(NSZone *)zone { @synchronized(self) { \ if (shared##classname == nil) { shared##classname = [super allocWithZone:zone]; return shared##classname; } } return nil; } - (id)copyWithZone:(NSZone *)zone \ { return self; } - (id)retain { return self; } - (NSUInteger)retainCount { return NSUIntegerMax; } - (void)release { } - (id)autorelease { return self; }

然而，eschaton则觉得这些实现都太繁琐了，他给出的实现如下：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

@interface SomeManager : NSObject + (id)sharedManager; @end /* 非线程安全的实现 */ @implementation SomeManager + (id)sharedManager { static id sharedManager = nil; if (sharedManager == nil) { sharedManager = [[self alloc] init]; } return sharedManager; } @end /* 线程安全的实现 */ @implementation SomeManager static id sharedManager = nil; + (void)initialize { if (self == [SomeManager class]) { sharedManager = [[self alloc] init]; } } + (id)sharedManager { return sharedManager; } @end

关于为什么上述代码就能实现单例模式，以及关于线程安全问题的考量，请参考他的博客。

最后介绍一个比较现代的单例模式实现。为什么说现代呢？因为这种实现利用了GCD（Grand Central Dispatch）和ARC（Automatic Reference Counting）。核心代码如下：

1 2 3 4 5 6 7 8 9

+ (id)sharedInstance { static dispatch_once_t pred = 0; __strong static id _sharedObject = nil; dispatch_once(&pred, ^{ _sharedObject = [[self alloc] init]; // or some other init method }); return _sharedObject; }

单次初始化

GCD还提供单词初始化支持，这个与pthread中的函数  pthread_once 很相似。GCD提供的方式的优点在于它使用block而非函数指针，这就允许更自然的代码方式：

这个特性的主要用途是惰性单例初始化或者其他的线程安全数据共享。典型的单例初始化技术看起来像这样（线程安全的）：

    + (id)sharedWhatever
    {
        static Whatever *whatever = nil;
        @synchronized([Whatever class])
        {
            if(!whatever)
                whatever = [[Whatever alloc] init];
        }
        return whatever;
    }

这挺好的，但是代价比较昂贵；每次调用  +sharedWhatever 函数都会付出取锁的代价，即使这个锁只需要进行一次。确实有更风骚的方式来实现这个，使用类似双向锁或者是原子操作的东西，但是这样挺难弄而且容易出错。

使用GCD，我们可以这样重写上面的方法，使用函数 dispatch_once：

    + (id)sharedWhatever
    {
        static dispatch_once_t pred;
        static Whatever *whatever = nil;
        dispatch_once(&pred, ^{
            whatever = [[Whatever alloc] init];
        });
        return whatever;
    }

这个稍微比 @synchronized方法简单些，并且GCD确保以更快的方式完成这些检测，它保证block中的代码在任何线程通过  dispatch_once 调用之前被执行，但它不会强制每次调用这个函数都让代码进行同步控制。实际上，如果你去看这个函数所在的头文件，你会发现目前它的实现其实是一个宏，进行了内联的初始化测试，这意味着通常情况下，你不用付出函数调用的负载代价，并且会有更少的同步控制负载。

作者还写了一个宏（gist）来方便使用，大家可以阅读作者的博文A note on Objective-C singletons了解详情。

大多数情况下，Apple官方文档里的单例模式的示例代码实现已经够用了。虽然它最繁琐，但是也是本文介绍的几种单例模式中最容易理解的一个。至于其他的实现就留给读者们根据需要选择和应用了。

static DataManager *sharedDataManager = nil;

+ (DataManager *) sharedManager
{
    @synchronized(self)
 {
        if (sharedDataManager == nil)
  {
            [[self alloc] init];
        }
    }
 
    return sharedDataManager;
}

+ (id)allocWithZone:(NSZone *)zone
{
    @synchronized(self)
 {
        if(sharedDataManager == nil)
  {
            sharedDataManager = [super allocWithZone:zone];
            return sharedDataManager;
        }
    }
 
    return nil;
}

(全文完)