简介
本文主要考虑的点，如下：
- 单例的实现方式有很多中，本文使用官方推荐的dispatch_once创建
- 分别讲述ARC和MRC下创建单例的方式
- 保持单例完整性，遵循了NSCopying,NSMutableCopying，适用ARC& MRC。
- 重写了allocWithZone、copyWithZone和MutableCopyWithZone方法，适用ARC& MRC。
- ARC下还需要重写retain、release、autoRelease、retainCount方法。
- 关于继承性
- 为了保证单例完整性，标记不能被继承
__attribute__ ((objc_subclassing_restricted)) - 关于继承的单例实现方案。
- 为了保证单例完整性，标记不能被继承
一、单例实现
1、ARC单例
- FengOnceClass.h
#import
NS_ASSUME_NONNULL_BEGIN
// 标记不能被继承
__attribute__ ((objc_subclassing_restricted))
@interface FengOnceClass : NSObject
+ (instancetype)sharedInstance;
@end
NS_ASSUME_NONNULL_END
- FengOnceClass.m
#import "FengOnceClass.h"
@implementation FengOnceClass
+ (instancetype)sharedInstance {
static FengOnceClass *sharedInstance = nil;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[super allocWithZone:NULL] init];//避免循环引用，故用super
});
return sharedInstance;
}
- (instancetype)init {
if (self = [super init]) {
//初始化，需要有初始化的就写，没有可以省略这个方法
}
return self;
}
#pragma mark --重写 保证为真正的单例
+ (id) allocWithZone:(struct _NSZone *)zone {
/*
* 需要考虑开发着的调用顺序，故不能直接return self；
* 因为开发者可能先调用alloc再调用sharedInstance
*/
//return self;
return [self sharedInstance];
}
/*
* 有的文章说需要重写new
* 但验证后，是不需要重写的
* new调用的就是alloc和init，只要重写allocWithZone就好了
*/
//+ (instancetype)new {
// return [self sharedInstance];
//}
/*
* copy和mutableCopy其实不重写也可以，但是会崩溃unrecognized selector sent to instance XXXX"
* 因为需要支持copy和mutableCopy必须支持NSCopying,NSMutableCopying协议
* 但是为了代码的严谨性还是重写一下比较好
* 可以直接return self，是因为iOS的记住，如果是实例为空对象，就不会调到实例方法
*/
/*
* copy和mutableCopy其实不重写也可以，但是会崩溃unrecognized selector sent to instance XXXX"
* 因为需要支持copy和mutableCopy必须支持NSCopying,NSMutableCopying协议
* 但是为了代码的严谨性还是重写一下比较好
* 其实可以直接return self，因为iOS的特性，如果是实例为空对象，就不会调到实例方法
* 但是为了代码的严谨性还是是用sharedInstance
*/
- (id)copyWithZone:(nullable NSZone *)zone {
Class selfClass = [self class];
return [selfClass sharedInstance];
}
- (id)mutableCopyWithZone:(nullable NSZone *)zone {
Class selfClass = [self class];
return [selfClass sharedInstance];
}
@end
2、MRC单例实现
-
说明
- 除了和ARC下一样，为了保持单例的完成性，实现NScopying协议, 覆盖allocWithZone:、copyWithZone和MutableCopyWithZone：方法,确保用户在直接分配和初始化对象时,不会产 生另一个对象。
- MRC还需要覆盖release、autorelease、retain、retainCount方法, 以此确保单例的状态。
-
实现
- FengOnceClass.h
#importNS_ASSUME_NONNULL_BEGIN // 标记不能被继承 __attribute__ ((objc_subclassing_restricted)) @interface FengOnceClass : NSObject - FengOnceClass.m
#import "FengOnceClass.h" @implementation FengOnceClass + (instancetype)sharedInstance { static FengOnceClass *sharedInstance = nil; static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ sharedInstance = [[super allocWithZone:NULL] init];//避免循环引用，故用super }); return sharedInstance; } - (instancetype)init { if (self = [super init]) { //初始化，需要有初始化的就写，没有可以省略这个方法 } return self; } #pragma mark --重写 保证为真正的单例 + (id) allocWithZone:(struct _NSZone *)zone { /* * 需要考虑开发着的调用顺序，故不能直接return self； * 因为开发者可能先调用alloc再调用sharedInstance */ //return self; return [self sharedInstance]; } - (id)copyWithZone:(nullable NSZone *)zone { Class selfClass = [self class]; return [selfClass sharedInstance]; } - (id)mutableCopyWithZone:(nullable NSZone *)zone { Class selfClass = [self class]; return [selfClass sharedInstance]; } #pragma mark --内存管理 - (oneway void)release { //重写release方法 保证外界对该类的唯一一个实例对象进行 release操作的同时 ， 不让该对象release掉 } // oneway 主要是真对多线程环境下的单向执行 ， 没有“回滚”操作 ， 也就是我们所说的原子操作 - (instancetype)autorelease{ return self; } // 当别人对我们这一块空间进行retain从操作的时候 , 不让该空间retain操作其效果 - (instancetype)retain { return self; } // 也可以返回MAXFLOAT，当外界访问这块空间的retainCount值的时候返回 -1 ， 或者2^64 - 1 ， 其实就是为了告诉访问者 ， 这块空间不是那么好管理的 ， 你就不要管理了 - (NSUInteger)retainCount { return 1; //重写retainCount锁定引用计数 } @end
3、为什么要标记成不可继承
现把FengOnceClass标记为不能被继承的标示屏蔽，然后定义一个FengOncePlusClass，什么都不做，不定义属性不定义方法，只是继承FengOnceClass，代码如下：
- FengOncePlusClass.h
//.h文件 #import "FengOnceClass.h" NS_ASSUME_NONNULL_BEGIN @interface FengOncePlusClass : FengOnceClass @end NS_ASSUME_NONNULL_END - FengOncePlusClass.m
#import "FengOncePlusClass.h" @implementation FengOncePlusClass @end - 使用如下：
FengOnceClass *test1 = [FengOnceClass sharedInstance]; test1.name = @"Feng"; FengOncePlusClass *test2 = [FengOncePlusClass sharedInstance]; test2.name = @"FengPlus"; NSLog(@"test1 %p test1.name %@ test2 %p test2.name %@",test1,test1.name,test2,test2.name); - 打印结果如下：
2020-11-24 16:47:03.574846+0800 BlueToothDemo[51487:3514206] test1 0x600002b70030 test1.name FengPlus test2 0x600002b70030 test2.name FengPlus - 分析：
地址都是一样的，然后name都变成了"FengPlus"，这显然不是我们想要的单例，不能保持单例的完成性了。所以还是要开启不能被继承的标示。但是如果业务有需求，需要实现可继承单例，又不影响单例，是否能实现了。答案是可以的，继续往下看。
4、可继承单例实现
-
在单例上做如下改动
- 屏蔽
不能被继承的标示 - 使用runTime的关联对象进行创建
- 屏蔽
-
FengOnceClass.h，
#importNS_ASSUME_NONNULL_BEGIN @interface FengOnceClass : NSObject -
FengOnceClass.m
#import "FengOnceClass.h" @implementation FengOnceClass //使用runTime的关联对象进行创建 +(instancetype)sharedInstance { Class selfClass = [self class]; // 从类中获取对象 id instance = objc_getAssociatedObject(selfClass, @"sharedInstance"); if (!instance) { // 不存在，创建对象 instance = [[super allocWithZone:NULL] init]; // 给类绑定对象 objc_setAssociatedObject(selfClass, @"sharedInstance", instance, OBJC_ASSOCIATION_RETAIN_NONATOMIC); } return instance; } - (instancetype)init { if (self = [super init]) { //初始化，需要有初始化的就写，没有可以省略这个方法 } return self; } + (id) allocWithZone:(struct _NSZone *)zone { return [self sharedInstance]; } - (id)copyWithZone:(nullable NSZone *)zone { Class selfClass = [self class]; return [selfClass sharedInstance]; } - (id)mutableCopyWithZone:(nullable NSZone *)zone { Class selfClass = [self class]; return [selfClass sharedInstance]; } @end -
使用如下：
FengOnceClass *test1 = [FengOnceClass sharedInstance]; test1.name = @"Feng"; FengOncePlusClass *test2 = [FengOncePlusClass sharedInstance]; test2.name = @"FengPlus"; NSLog(@"test1 %p test1.name %@ test2 %p test2.name %@",test1,test1.name,test2,test2.name); -
打印结果和分析如下：
可继承单例
二、单例的相关知识
1、什么是单例
一个单例类，在整个程序中只有一个是实例，并且提供一个类方法供全局调用。
2、系统为我们提供的单例有哪些
UIApplication(应用程序实例类)
NSNotificationCenter(消息中心类)
NSFileManager(文件管理类)
NSUserDefaults(应用程序设置)
NSURLCache(请求缓存类)
NSHTTPCookiesStorage(应用程序cookies池)
3、哪些地方会用到单例模式
一般在程序中，经常调用的类，比如工具类、公共跳转类
4、单例模式的生命周期
单例实例在存储器的全局区域，在编译时分配内存，在APP结束后由系统释放这部分内存。
请看下面的表格展示展示了程序中不同的变量在手机存储器中的存储位置
| 位置 | 存放的变量 |
|---|---|
| 栈 | 临时变量 （由编译器管理自动创建/分配/释放的，栈中的内存被调用时处于存储空间中，调用完毕后由系统系统自动释放内存） |
| 堆 | 通过alloc、malloc或new申请内存，由开发者手动在调用之后通过free或delete释放内存。动态内存的生存期可以由我们决定，如果我们不释放内存，程序将在最后才释放掉动态内存，在ARC模式下，由系统自动管理。 |
| 全局区域 | 静态变量（编译时分配，APP结束时由系统释放） |
| 常量 | 常量（编译时分配，APP结束时由系统释放） |
| 代码区 | 存放代码 |
5、单例创建方式
- 同步锁NSLock
- @synchronized(self) {}
- 信号量控制并发：dispatch_semaphore_t
- 条件锁：NSConditionLock
- dispatch_once_t【官方推荐】
6、单例模式优缺点
- 优点
- 可以快速的定位问题：因为整个程序中只会实例化一次；
- 节省了系统内存资源
- 提高了程序的运行效率
- 缺点
- 不易继承、不易有子类（有继承的需求，适用runtimer创建）
- 不易被重写或扩展（可以使用分类）
- 在闲置时也消耗了系统内存资源
7、单例创建需要解决的问题
-
问题一：重写单例类alloc方法保证这个类只会被初始化一次
- 处理方案一：抛异常：使用断言或系统为开发者提供的NSException类来告诉开发者这个类是单例类，不能多次初始化
//断言 + (instancetype)alloc { NSCAssert(onceShare, @"FengOnceClass类只能初始化一次"); //如果已经初始化了 抛异常 return [super alloc]; }//NSException + (instancetype)alloc { if (onceShare) { //如果已经初始化了 抛异常 NSException *exception = [NSException exceptionWithName:@"提示" reason:@"FengOnceClass类只能初始化一次" userInfo:nil]; [exception raise]; } return [super alloc]; // 不可以直接return单例，因为可能先调用的alloc，在调用的单例方法 // return onceShare } - 多次初始化，就会崩溃，报如下错:
使用
异常
这种方式系统UIApplication单例也是使用了，如下：
断言方式
- 处理方案一：抛异常：使用断言或系统为开发者提供的NSException类来告诉开发者这个类是单例类，不能多次初始化
处理方案二：直接返回单例：通过判断，如果存在，就直接返回单例，如果不存在在去创建。比如：
+ (instancetype)alloc {
if (onceShare) {
return onceShare;
}
return [super alloc];
}
-
问题二：对于new、copy、mutableCopy的处理
- 处理方案一：重写这几个方法，当调用时提示或返回单例的实列，参考alloc;
- 处理方案二：直接禁用这几个方法，禁止调用这几个方法，否则就报错，编译不过。
//头文件中添加如下方法： +(instancetype) new __attribute__((unavailable("FengOnceClass类只能初始化一次"))); -(instancetype) copy __attribute__((unavailable("FengOnceClass类只能初始化一次"))); -(instancetype) mutableCopy __attribute__((unavailable("FengOnceClass类只能初始化一次")));添加禁用方法后，如果使用就会报如下错：
禁用后的报错 示例一：不禁用，不使用断言/NSException --【推荐】
#import
NS_ASSUME_NONNULL_BEGIN
// 标记不能被继承
__attribute__ ((objc_subclassing_restricted))
@interface FengOnceClass : NSObject
+ (instancetype)sharedInstance;
@end
NS_ASSUME_NONNULL_END
#import "FengOnceClass.h"
@implementation FengOnceClass
+ (instancetype)sharedInstance {
static FengOnceClass *sharedInstance = nil;
if (!sharedInstance) {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[super allocWithZone:NULL] init];//避免循环引用，故用super
/*
* 如果alloc不调用sharedInstance
* 而是直接拷贝sharedInstance的方法，就可使用self
* 但是不推荐，有代码冗余，推荐使用super
*/
//sharedInstance = [[self allocWithZone:NULL] init];
});
}
return sharedInstance;
}
- (instancetype)init {
if (self = [super init]) {
//初始化，需要有初始化的就写，没有可以省略这个方法
}
return self;
}
#pragma mark --重写 保证为真正的单例
+ (id) allocWithZone:(struct _NSZone *)zone {
return [self sharedInstance];
}
/*
* 有的文章说需要重写new
* 但验证后，是不需要重写的
* new调用的就是alloc和init，只要重写allocWithZone就好了
*/
//+ (instancetype)new {
// return [self sharedInstance];
//}
/*
* copy和mutableCopy其实不重写也可以，但是会崩溃unrecognized selector sent to instance XXXX"
* 因为需要支持copy和mutableCopy必须支持NSCopying,NSMutableCopying协议
* 但是为了代码的严谨性还是重写一下比较好
*/
- (id)copyWithZone:(nullable NSZone *)zone {
return self;
}
- (id)mutableCopyWithZone:(nullable NSZone *)zone {
return self;
}
@end
地址都是一样的啦
- 示例二：禁用
#import
NS_ASSUME_NONNULL_BEGIN
@interface FengOnceClass : NSObject
+(instancetype) new __attribute__((unavailable("FengOnceClass类只能初始化一次")));
-(instancetype) copy __attribute__((unavailable("FengOnceClass类只能初始化一次")));
-(instancetype) mutableCopy __attribute__((unavailable("FengOnceClass类只能初始化一次")));
+ (instancetype)sharedInstance;
@end
NS_ASSUME_NONNULL_END
#import "FengOnceClass.h"
static FengOnceClass *sharedInstance = nil;
@implementation FengOnceClass
+ (instancetype)sharedInstance {
if (!sharedInstance) {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedInstance = [[super allocWithZone:NULL] init];
});
}
return sharedInstance;
}
+ (id) allocWithZone:(struct _NSZone *)zone {
//方式一：断言
NSCAssert(sharedInstance, @"FengOnceClass类只能初始化一次");
//方式二：NSException
// if (sharedInstance) { //如果已经初始化了 抛异常
// NSException *exception = [NSException exceptionWithName:@"提示" reason:@"FengOnceClass类只能初始化一次" userInfo:nil];
// [exception raise];
// }
return [self sharedInstance];
}
@end
参考资料：
- 《iOS单例的精心设计历程》
- 《iOS单例继承》