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 <Foundation/Foundation.h>
#import "SingleTonMacroDefine.h"
@interface GloableSingleTon : NSObject
JWSingletonH(GloableSingleTon)
@end
.m文件
#import "GloableSingleTon.h"
@implementation GloableSingleTon
JWSingletonM(GloableSingleTon)
@end
使用@synchronized(self)互斥锁的方式创建单例类
.h文件
#import <Foundation/Foundation.h>
@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判断语句上也做了优化(逼格有点高)，使得其效率有很大的提升；
###注意：
>通常来说，单例类的生命周期贯穿于整个应用的生命周期中，你**不应该保存太多其它对象的强引用**，因为他们只有到应用关闭的时候才能被释放。
####觉得好，给个关注，谢谢。