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判斷語句上也做了優化(逼格有點高)，使得其效率有很大的提升；
###注意：
>通常來說，單例類的生命周期貫穿于整個應用的生命周期中，你**不應該保存太多其它對象的強引用**，因為他們只有到應用關閉的時候才能被釋放。
####覺得好，給個關注，謝謝。