iOS设计模式之Singleton

Singleton 单例设计模式

单例设计模式确保对于一个给定的类只有一个实例存在，这个实例有一个全局唯一的访问点。它通常采用懒加载的方式在第一次用到实例的时候再去创建它；

Apple Developer的Singleton

singleton

以下为苹果官方文档的翻译：

无论一个应用程序请求它多少次，一个单例类(Singleton)都返回相同的实例。一个典型的类(Typical class)允许调用者创建出想要的尽可能多的实例,而一个单例类每个进程中只能有一个实例。一个单例对象提供了一个全局的资源的访问点。单例对象被用在这是这些情况下：例如提供一些普遍的服务和资源的类。

你通过工厂方法从一个单例类中获得一个全局实例。在第一次request后，类以懒加载的方式创建它的唯一实例,并确保没有其他实例可以被创建。一个单例类还可以防止调用者copy、retain或release实例。如果你有需要，你可以创建自己的单例类。如果你有一个这样的类,在应用程序中它为其他对象提供声音,您可能会使它成为一个单例。

有些Cocoa框架类是单例类。其中包括NSFileManager,NSWorkspace,及在UIKit框架中的UIApplication和UIAccelerometer类。工厂方法返回单例类实例的名称,按照惯例,采用sharedClassType形式。例如：Cocoa框架中的sharedFileManager,sharedColorPanel,sharedWorkspace。

使用dispatch_once方式创建单例

在ARC环境下

.h文件

@interface GeneralTools : NSObject

//提供一个类方法
//1.表明身份,说明这是一个单例
//2.方便外界访问
//3.注意点:类方法命名规范,一般以shared+类名|default+类名|类名
+ (GeneralTools *)sharedTools;

@end

.m文件

#import "GeneralTools.h"

@implementation GeneralTools

//首先将唯一实例存储在静态区（因为用static 标记过）
static GeneralTools *_instance = nil;

//其次分配内存空间
/*
 因为alloc内部会调用allocWithZone，也就是说allocWithZone方法更底层。也就是说我们实现alloc方法的话就只能拦截alloc方法，但是实现allocWithZone方法的话，任何内存分配的方法我们都能拦截。
 */
+(instancetype)allocWithZone:(struct _NSZone *)zone{
    //只进行一次
    //调用dispatch_once保证在多线程中也只被实例化一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [super allocWithZone:zone];
    });
    return _instance;
}

//单例方法
+(GeneralTools *)sharedTools{
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[self alloc] init];
    });
    return _instance;
}

//copy在底层 会调用copyWithZone:
- (id)copyWithZone:(NSZone *)zone{
    return  _instance;
}

- (id)mutableCopyWithZone:(NSZone *)zone{
    return _instance;
}

@end

在MRC环境下

.h文件

@interface MRCTools : NSObject

+ (MRCTools *)sharedMRCTools;

@end

.m文件

#import "MRCTools.h"

@implementation MRCTools

static MRCTools *_instance = nil;

+ (instancetype)allocWithZone:(struct _NSZone *)zone{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [super allocWithZone:zone];
    });
    return _instance;
}

+ (MRCTools *)sharedMRCTools{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[self alloc] init];
    });
    return _instance;
}

- (id)copyWithZone:(NSZone *)zone{
    return _instance;
}

- (id)mutableCopyWithZone:(NSZone *)zone{
    return _instance;
}
//如果是MRC
#if !__has_feature(objc_arc)

- (id)retain {
    return self;
}

- (id)autorelease {
    return self;
}

- (oneway void)release {
    //never release
}

- (NSUInteger)retainCount {
    return UINT_MAX;  
    //表示对象永远不可能被释放，因为引用计数是无限大
}
#endif

oneway关键字应用于分布式对象的API,即允许不同的线程或应用程序之间使用Objective-C的对象。oneway告诉系统,在返回值返回前不应该阻止线程的调用。没有oneway,调用者将阻止,尽管该方法的返回类型是void。很明显,相比于void它是不会被使用的,这样做就意味着方法返回了某些东西,但是调用者没有得到它。

将单例的创建抽取成宏的方式

//##classname ##表示拼接字符
#define JWSingletonH(classname) + (classname *)shared##classname;

#if __has_feature(objc_arc)

#define JWSingletonM(classname)\   //"\"代表这句代码还没有结束，包括下一行
static classname *_instance = nil;\
\
+ (instancetype)allocWithZone:(struct _NSZone *)zone{\
    static dispatch_once_t onceToken;\
    dispatch_once(&onceToken, ^{\
        _instance = [super allocWithZone:zone];\
    });\
    return _instance;\
}\
\
+ (classname *)shared##classname{\
    static dispatch_once_t onceToken;\
    dispatch_once(&onceToken, ^{\
        _instance = [[self alloc] init];\
    });\
    return _instance;\
}\
\
- (id)copyWithZone:(NSZone *)zone{\
    return _instance;\
}\
\
- (id)mutableCopyWithZone:(NSZone *)zone{\
    return _instance;\
}
//如果是MRC
#else

#define JWSingletonM(classname)\
static classname *_instance = nil;\
\
+ (instancetype)allocWithZone:(struct _NSZone *)zone{\
static dispatch_once_t onceToken;\
dispatch_once(&onceToken, ^{\
_instance = [super allocWithZone:zone];\
});\
return _instance;\
}\
\
+ (classname *)shared##classname{\
static dispatch_once_t onceToken;\
dispatch_once(&onceToken, ^{\
_instance = [[self alloc] init];\
});\
return _instance;\
}\
\
- (id)copyWithZone:(NSZone *)zone{\
return _instance;\
}\
\
- (id)mutableCopyWithZone:(NSZone *)zone{\
return _instance;\
}\
- (id)retain {\
    return self;\
}\
- (id)autorelease {\
    return self;\
}\
- (oneway void)release {\
}\
- (NSUInteger)retainCount {\
    return UINT_MAX;\
}

#endif

以后只需要创建一个头文件将此代码放入头文件中即可；在使用时将此头文件导入需要创建单例的文件中即可；详见下面创建实例：

.h文件

#import 
#import "SingleTonMacroDefine.h"

@interface GloableSingleTon : NSObject

JWSingletonH(GloableSingleTon)

@end

.m文件

#import "GloableSingleTon.h"

@implementation GloableSingleTon

JWSingletonM(GloableSingleTon)

@end

使用@synchronized(self)互斥锁的方式创建单例类

.h文件

#import 

@interface SynchronizedSingle : NSObject

+ (instancetype)sharedInstance;

@end

.m文件

#import "SynchronizedSingle.h"

@implementation SynchronizedSingle

static id _instance;

+ (instancetype)allocWithZone:(struct _NSZone *)zone{
    @synchronized(self) {
        if (!_instance) {
            _instance = [super allocWithZone:zone];
        }
    }
    return _instance;
}

+ (instancetype)sharedInstance{
    @synchronized(self) {
        if (!_instance) {
            _instance = [[self alloc] init];
        }
    }
    return _instance;
}

- (id)copyWithZone:(NSZone *)zone
{
    return _instance;
}

- (id)mutableCopyWithZone:(NSZone *)zone{
    return _instance;
}

#if !__has_feature(objc_arc)
- (id)retain {
    return self;
}

- (id)autorelease {
    return self;
}

- (oneway void)release {
    //never release
}

- (NSUInteger)retainCount {
    return UINT_MAX;  //表示对象永远不可能被释放，因为引用计数是无限大
}
#endif
@end

互斥锁的工作机制：

假设此时线程A在执行sharedInstance方法，那么synchronize大括号内创建单例的代码，如下所示：

if (_instance == nil) {
_instance = [[self alloc] init];
}

>就会被当做一个任务被加上了一把锁。此时假设线程B也想执行`sharedInstance`方法创建单例，但是看到了线程A加的互斥锁，就会进入睡眠模式。等到线程A执行完毕，才会被唤醒，然后去执行上面所示的创建单例的代码，但是此时`_instance !=nil`,所以不会再创建新的实例对象了。从而保证只会创建一个实例对象。

> 但是互斥锁会影响性能，所以最好还是使用GCD方式创建单例。

####dispatch_once的工作机制：
>`dispatch_once`保证程序在运行过程中只会被运行一次，那么假设此时线程A先执行`sharedInstance`方法，创建了一个实例对象，线程B就不会再去执行`dispatch_once`的代码了。从而保证了只会创建一个实例对象。
>  

###总结：
>**为什么dispatch_once性能优于@synchronized互斥锁？** 
>
>`@synchronized`采用的是递归互斥锁来实现线程安全，而`dispatch_once`的内部则使用了很多原子操作来替代锁，以及通过信号量来实现线程同步，而且有很多针对处理器优化的地方，甚至在if判断语句上也做了优化(逼格有点高)，使得其效率有很大的提升；


###注意：
>通常来说，单例类的生命周期贯穿于整个应用的生命周期中，你**不应该保存太多其它对象的强引用**，因为他们只有到应用关闭的时候才能被释放。

####觉得好，给个关注，谢谢。