Object-C 中的单例模式

最近很多文章都在讲如何在 Object-C 中实现单例，但是它们大都没有讲全。

首先来看看 单例(Singleton) 的定义:

In software engineering, the singleton pattern is a design pattern that restricts the instantiation of a class to one object. This is useful when exactly one object is needed to coordinate actions across the system.

来自Wikipedia

就是说，单例模式的目的就是在应用程序的生命周期中，限制某个类的实例只能有一个。

下面来看几个在 OC 中常用的『单例』方式。

方式1

方式1符合那些具有面向对象编程经验的程序员一般思维，因此很自然的会想到下面的实现方式：

@interface DownloadManager : NSObject
@end

@implementation DownloadManager
static DownloadManager* _sharedInstance = nil;

+ (DownloadManager*)manager
{
    @synchronized(self.class)
    {
        if (_sharedInstance == nil) {
            _sharedInstance = [[self.class alloc] init];
        }

        return _sharedInstance;
    }
}
@end

注意上面代码中使用了 @synchronized 来确保在多线程情况下也可以正常的工作。之后我们会按照『约定』，凡是在需要获得 DownloadManager 实例时，统一使用：

DownloadManager* manager = [DownloadManager manager];

方式2

@interface DownloadManager : NSObject
@end

@implementation DownloadManager

+ (DownloadManager*)manager
{
    static DownloadManager* instance = nil;
    static dispatch_once_t once;

    dispatch_once(&once, ^{
        instance = [[self.class alloc] init];
    });
    return instance;
}
@end

上面的代码使用了 dispatch_once 来确保创建实例的代码只会被运行一次。注意这次我们并没有使用 @synchronized 这是因为 dispatch_once 是 thread-safety，这是 Apple Doc 中的相关描述：

This function is useful for initialization of global data (singletons) in an application. Always call this function before using or testing any variables that are initialized by the block.

If called simultaneously from multiple threads, this function waits synchronously until the block has completed.

The predicate must point to a variable stored in global or static scope. The result of using a predicate with automatic or dynamic storage (including Objective-C instance variables) is undefined.

同样的，之后我们也会按照约定，凡是在需要获得 DownloadManager 实例时，统一使用：

DownloadManager* manager = [DownloadManager manager];

注意到上面的文字描述中，多次强调了按照『约定』，为什么这么说呢？这是因为，即使我们定义了 manager 这个方法，但是我们并不能确保调用者不会这样使用：

DownloadManager* manager = [[DownloadManager alloc] init];

所以说，上面的方式1和方式2实际上严格来说，并不是真正的『单例模式』

Swift 中的单例

为了有一个对比，知道什么是严格意义的单例模式，我们可以看看在 Swift 中如何实现单例模式：

class DownloadManager {
    static let manager = DownloadManager()
    private init() { }
}

注意到使用了 private 来限制了 init 的访问级别，我们知道在 Swift 中访问控制的最小颗粒度是到文件级别，这并不是问题，因为通常我们会把类定义在一个单独的文件中。

现在在需要获取 DownloadManager 的实例时，只能通过：

let manager = DownloadManager.manager

如果你试图这样（注意访问控制的最小颗粒度是文件）：

let manager = DownloadManager()

你会得到一个错误提示：

到底是方式1还是方式2

现在我们知道了在 OC 中如果需要实现单例模式的话，有上面的方式1和方式2两种方式，那么我们应该选择它们中的哪一个呢？答案是方式2。

我们选择方式2的原因有这么几个：

1. 从语义上来讲，方式2更加的清晰明了，因为我们知道 dispatch_once 的意思就是对某个任务只执行一次，这很符合我们单例的需求。
2. 从性能上来说，dispatch_once 具有更高的性能。

说到性能问题，最好还是有 benchmark tests，刚好有人已经做了相关的测试，下面就是他测试的结果：

Single threaded results
-----------------------
  @synchronized: 3.3829 seconds
  dispatch_once: 0.9891 seconds

Multi threaded results
----------------------
  @synchronized: 33.5171 seconds
  dispatch_once: 1.6648 seconds

如果你需要测试的源码的话，可以去作者的基hub。

从上面的测试中我们看到 dispatch_once 不管在多线程还是单线程情况下，都要比 @ synchronized 快很多。

作为最后的结语，让我们拥抱 Swift 吧。

总有阳光的人给我点赞