iOS 单例模式 浅叙

单例模式作用

可以保证在程序运行过程中，一个类只有一个实例，而且该实例易于供外界使用

从而方便地控制了实例个数，并节约系统资源

单例模式使用场合

在整个引用程序中，共享一份资源（这份资源只需要创建初始化1次，只分配一次存储空间）

例如：背景音乐，音频调节器等

单例的简单使用

使用单例的目的就是为了要在程序运行过程中，共享一份资源，且这份资源只会初始化一次，只分配一次存储空间，节约系统资源；先来看一下平时我们创建对象时，内存地址的变化情况：

##### 创建对象内存分配地址演示

1.这里用SJTools这个类来演示

//  创建SJTools类
SJTools *tool1 = [[SJTools alloc] init];

SJTools *tool2 = [SJTools new];

SJTools *tool3 = [[SJTools alloc] init];

NSLog(@"\ntool1%@:\ntool2%@:\ntool3%@:",tool1, tool2, tool3);

执行结果：从打印的内存地址可以看出——每次创建同一个类，都会分配新的内存地址，这在某些场合是没有必要的（比如播放音乐，一般我们不会有在同一个播放器同时播放多首歌的情况出现），而且系统的资源是有限的，特别是移动设备，所以前辈们总结出新的模式——单例

##### 单例创建演示

1.这里依旧使用SJTools这个类演示

现在我们的目的是类无论创建多少次，都

只分配一次存储空间

，而分配存储空间的操作是在

alloc:

中执行，所以我们要重写类中的

alloc:

类方法

那么我们通过以下几种思路来实现单例

+ (instancetype)alloc
+ (instancetype)allocWithZone:(struct _NSZone *)zone

在重写

alloc:

过程中，我们发现有个

allocWithZone:

方法,这个和

alloc:

方法有什么区别呢？——其实，

alloc:

方法内部最终会去调用

allocWithZone:

方法来分配存储空间，所以为了能更深层控制，我们放弃重写

alloc:

方法，直接重写

allocWithZone:

方法。

思路一（ARC模式下单例模式的实现）

1.因为是类方法，且不想外面获取到这个变量，所以我们先定义一个静态变量

//  声明一个静态变量（不然外界获取到）
static SJTools *_instance;

1.2 重写

allocWithZone:

方法

1.2.1 第一种方式 —— 懒加载

+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
//  考虑到使用时可能在多条线程同时执行此方法任务，那么就可能引发线程安全问题，所以我们需要对线程进行加锁操作
@synchronized(self) {
if (_instance == nil) { //  如果为nil就执行以下操作
_instance = [super allocWithZone:zone];
}
}
return _instance;
}

1.2.2 第二种方式 —— GCD一次性代码

+ (instancetype)allocWithZone:(struct _NSZone *)zone
{
//  我们也可以使用GCD提供给我们的一次性代码函数来实现，因为它本身就是线程安全的
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
_instance = [super allocWithZone:zone];
});

return _instance;
}

到这里，简单的单例就实现了，但是还有一些问题需要解决，先不管，先Run来试一下是不是管用

执行结果：从结果可以看出，确实所有创建的操作只分配了一次内存



为了让我们的单例严谨一点，我们还要考虑copy这种情况，所以我们还要重写copy和mutableCopy

1.1 要重写copy和mutableCopy方法，必须先遵守协议

@interface SJTools()<NSCopying, NSMutableCopying>

1.2 重写copy和mutableCopy方法

- (id)copyWithZone:(NSZone *)zone
{
//  直接返回变量即可，因为只有创建了对象，才能使用copy方法
return _instance;
}

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

为了供外界方便访问，我们还需要提供相应的调用方法，一般我们会提供给外界一个类方法供外界使用，这也牵扯到命名的问题，怎样命名才规范，这里顺便提一下

一般常见的命名形式有这几种 —— share 、share + 类名 、default、default + 类名

优点：

减少沟通成本

方便外界访问

1.在.h文件中声明

/**
*  获取单例对象
*/
+ (instancetype)shareSJTools;

2.在.m文件中实现

+ (instancetype)shareSJTools
{
//  返回实例对象
return [[self alloc] init];
}

到这来我们的单例模式就实现了，但是上面的方式在MRC环境下就不好用了，那有没有同时在ARC和MRC中都可使用的方法呢？下面我们就来解决这样的问题。

思路二（MRC下单例模式的实现）

首先，需要MRC的环境，需要先修改一下XCode配置



接下来需要修改下前面创建对象的代码，让其符合MRC规则,并运行

//  创建SJTools类
SJTools *tool1 = [[SJTools alloc] init];

[tool1 release];

SJTools *tool2 = [SJTools new];
[tool2 release];

SJTools *tool3 = [[SJTools alloc] init];
[tool3 release];

NSLog(@"\ntool1%@:\ntool2%@:\ntool3%@:",tool1, tool2, tool3);

执行结果：编译器提示我们消息发送给已经释放的对象，这是因为我们在创建对象后，对其进行了release操作，这样对象的计数器为0，系统就将会其释放，所以在设计单例时我们还需要考虑MRC的环境。



因为单例的生命周期是从被创建的那一刻起，到程序运行结束，也就是说，我们可以不用理会MRC中的规则，但是又不想破坏使用者的使用习惯，那么我们可以在类中重写

retain

，

release

，

retainCount

方法，使其不受外界影响。

- (oneway void)release
{
//  因为我们不理会MRC规则，所以在release方法中可以什么都不做
}

- (instancetype)retain
{
//  因为retain方法要求返回一个instancetype返回值，我们直接返回变量
return _instance;
}

- (NSUInteger)retainCount
{
//  在之前的一些早期的MRC项目中发现，单例中普遍会直接给retaiCount一个MAXFLOAT作为返回值，这样做应该是为了让外界认为这个类是单例，进一步减少沟通成本
return MAXFLOAT;
}

执行结果：这样程序就能正常运行了



为了让单例在

ARC

和

MRC

模式下都能愉快使用，我们可以使用宏来判断当前系统环境，并做出对应处理

#ifdef __has_feature(objc_arc)

//  ARC环境
#else

//  MRC环境
- (oneway void)release
{
//  因为我们不理会MRC规则，所以在release方法中可以什么都不做
}

- (instancetype)retain
{
//  因为retain方法要求返回一个instancetype返回值，我们直接返回变量
return _instance;
}

- (NSUInteger)retainCount
{
//  在之前的一些早期的MRC项目中发现，单例中普遍会直接给retaiCount一个MAXFLOAT作为返回值，这样做应该是为了让外界认为这个类是单例，进一步减少沟通成本
return MAXFLOAT;
}

#endif

到此，我们的单例就可以欢快地使用了。

单例模式使用注意

单例是不可继承的，我们可以来演示一下

首先，新建一个

SJNewTools

类，并让他继承

SJTools

，然后打印一下创建SJTools对象和SJNewTools对象后的内存地址

//  创建SJTools类
SJTools *tool1 = [SJTools shareSJTools];

//  创建SJNewTools类
SJNewTools *newTool1 = [SJNewTools shareSJTools];

NSLog(@"\ntool1%@:\nnewTool1%@:\n",tool1, newTool1);

执行结果：打印出来的内存地址是相同的，而且他们的真实类型都是

SJTools

为什么会这样？

其实是因为

alloc:

方法内部会调用

allocWithZone:

方法，在

allocWithZone:

内会对_instance这个变量进行初始化，给它分配存储空间；在这个阶段的时候，系统会去判断这个变量的真实类型，因为当前变量的类型是SJTools类型，所以_instance变量就是SJTools类型，后面SJNewTools继承了SJTools，但是内部使用的是同一个变量，就造成了上面的情况，所以，单例是不能继承的。

懒人福音 —— 单例的复用

在开发中，一般出现像这样可能复用的代码，而又不能继承的方式，那简直对我们这种

懒人

的晴天霹雳！难道每次要使用单例都要敲着这样一大串恶心的代码么？其实，我们还可以用宏来解决这样的事情嘛O(∩_∩)O

首先，因为单例可以分为2部分，一部分是.h文件，一部分是.m文件，所以，宏要分开来写 —— 先创建一个.h文件

Singleton.h文件

1.因为我们在只需要提供一个方法给外界使用，而且为了让其用起来更加清晰，我们给其加入参数

宏内怎么接收和使用参数呢？

格式：

#define 宏名(参数名) ##参数名

#define SingletonH(name) +(instancetype)share##name;

2.将之前我们在SJTools类的.m文件所做的操作拷贝过来，但会发现除了第一行以外的所有代码段都是没有列入宏的范围内（颜色不同）；这时候需要使用""符来进行连接，同样，我们要让外界传入参数来改变方法名，让其与.h文件相对应；同时变量的类型直接修改为

id

类型即可。

#define SingletonW(name) static id _instance;\
\
+ (instancetype)allocWithZone:(struct _NSZone *)zone\
{\
static dispatch_once_t onceToken;\
dispatch_once(&onceToken, ^{\
_instance = [super allocWithZone:zone];\
});\
\
return _instance;\
}\
\
+ (instancetype)share##name\
{\
return [[self alloc] init];\
}\
\
- (id)copyWithZone:(NSZone *)zone\
{\
return _instance;\
}\
\
- (id)mutableCopyWithZone:(NSZone *)zone\
{\
return _instance;\
}

这样宏就已经做好了，我们只需要在要使用单例的类中先引入头文件，然后在.h文件中这样使用

#import <Foundation/Foundation.h>
#import "Singleton.h"

@interface SJTools : NSObject

SingletonH(SJTools)

@end

.m文件中这样使用就可以了

@implementation SJTools

SingletonW(SJTools)

@end

为了使我们的宏能同时ARC和MRC，我们需要将宏判断部分也加入到单例宏中，但是宏判断是不能内嵌的，所以只能先判断环境，再分别进行相应操作

#define SingletonH(name) +(instancetype)share##name;

#if __has_feature(objc_arc)

//  ARC环境
#define SingletonW(name) static id _instance;\
+ (instancetype)allocWithZone:(struct _NSZone *)zone\
{\
static dispatch_once_t onceToken;\
dispatch_once(&onceToken, ^{\
_instance = [super allocWithZone:zone];\
});\
\
return _instance;\
}\
+ (instancetype)share##name\
{\
return [[self alloc] init];\
}\
- (id)copyWithZone:(NSZone *)zone\
{\
return _instance;\
}\
- (id)mutableCopyWithZone:(NSZone *)zone\
{\
return _instance;\
}

#else

//  MRC环境
#define SingletonW(name) static id _instance;\
+ (instancetype)allocWithZone:(struct _NSZone *)zone\
{\
static dispatch_once_t onceToken;\
dispatch_once(&onceToken, ^{\
_instance = [super allocWithZone:zone];\
});\
\
return _instance;\
}\
+ (instancetype)share##name\
{\
return [[self alloc] init];\
}\
- (id)copyWithZone:(NSZone *)zone\
{\
return _instance;\
}\
- (id)mutableCopyWithZone:(NSZone *)zone\
{\
return _instance;\
}\
- (oneway void)release\
{\
}\
- (instancetype)retain\
{\
return _instance;\
}\
- (NSUInteger)retainCount\
{\
return MAXFLOAT;\
}

#endif

好了，这样我们的单例宏就完成了，只要在需要的项目中导入这个宏，然后在需要的地方使用宏就可以了！