iOS设计模式之Singleton

Singleton 单例设计模式

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

Apple Developer的Singleton

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

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

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

有些Cocoa框架类是单例类。其中包括NSFileManager,NSWorkspace,及在UIKit框架中的UIApplicationUIAccelerometer类。工厂方法返回单例类实例的名称,按照惯例,采用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判断语句上也做了优化(逼格有点高),使得其效率有很大的提升;

注意:

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

觉得好,给个关注,谢谢。

转载于:https://juejin.im/post/5a31f0276fb9a044fb07c5ef

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值