单例

作者: 猪队友小L | 来源:发表于2017-08-18 16:57 被阅读60次

Android设计模式总结
IOS单例模式的底层原理
【设计模式】单例模式
2020-11-02-Spring单例 vs. 单例模式
IOS学习笔记之单例
OC - 单例模式
单例
单例模式
关于java单例模式，这篇已经讲得很清楚了，建议收藏！
单例

什么是单例

一句话概括: 有且仅有一个实例化对象的类,可以全局访问

单例的原理:

单例在堆内存创建了一个指针,这个指针指向一个实例化的自身,且仅能实例化一次
开放一个外部访问接口,每次访问返回指针
并且重写所有可能造成二次初始化的函数,让数据仅能初始化一次,保证数据安全.
通常单例无法被释放,比如Pods里的各种模块

OC中如何创建单例

因为已经是Xcode7.2了,所以仅仅讨论ARC模式下,以下是各种Pods库常用的单例创建模式.

干货代码

//.h
@interface ExampleSingleton : NSObject
+ (instancetype)shareInstance;
@end

//.m
@implementation ExampleSingleton

+ (instancetype)shareInstance {
    
    static ExampleSingleton *sharedInstance = nil;
    static dispatch_once_t onceToken;
    
    dispatch_once(&onceToken, ^{
        sharedInstance = [[ExampleSingleton alloc] init];
    });
    //NSLog(@"Access ExampleSingleton ShareInstance %p",sharedInstance);
    return sharedInstance;
}

- (instancetype)init {
    self = [super init];
    if (self) { 
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        //Initial Data
    });
    }
    return self;
}

@end

代码分析

开放一个类方法用来作为访问接口
声明一个ExampleSingleton的静态指针,先指向nil
init和shareInstance声明一个静态的GCD计数onceToken
shareInstance根据onceToken仅执行一次init,用静态指针指向实例化空间,保证其不被释放(原理1/2)
每次访问shareInstance,返回静态指针本身,传递出实例化的地址
init也根据onceToken仅初始化一次数据,以防使用者强行访问[[ExampleSingleton shareInstance]init]重置数据(原理3)

onceToken是什么

是GCD里一种计数器,本身是个long类型,每次执行一次就自动减1,直到数值小于0,不再执行.dispatch_once_t初始化的值为0,执行一次后为-1,下次再dispatch_once时由于小于0就不再执行.

GCD计数在读取通讯录里也用到了dispatch_semaphore_t,可以自定义执行几次

/*!
 * @typedef dispatch_once_t
 *
 * @abstract
 * A predicate for use with dispatch_once(). It must be initialized to zero.
 * Note: static and global variables default to zero.
 */
typedef long dispatch_once_t;

Tips: 值得注意的是dispatch_once(&onceToken, ^{});采用的是传址形式,因为long为C类型的数据,详见我的C类型变量传值和传址的文章.

单例真的不可释放么

由于通常单例只能被创建一份,并且伴随着Application的生命周期可以全局访问,所以好多教程中都说单例不可以被释放.其实这个观点是错误的,单例不可被释放只是保证了他的安全性.

如果我有一个模块,需要一个资源池,但是我不保证模块什么时候被启动,设置一个伴随着Application的单例感觉会浪费内存,可不可以实现随着模块启动创建资源池,模块关闭停止资源池.以下是我自己可以随时启动和关闭的单例.

一个可以被释放的单例

@interface ExampleSingleton : NSObject
+ (instancetype)shareInstance;
+ (void)haltSharedInstance;
@end

static ExampleSingleton *_sharedInstance = nil;
static dispatch_once_t _onceToken;

@implementation ExampleSingleton

+ (instancetype)shareInstance {
    dispatch_once(&onceToken, ^{
        _sharedInstance = [[ExampleSingleton alloc] init];
        if(_sharedInstance) {
        //Initial Data
        }
        NSLog(@"ExampleSingleton ShareInstance Did Create %p",sharedInstance);
    });
    //NSLog(@"Access ExampleSingleton %p",sharedInstance);
    return _sharedInstance;
}

+ (void)haltSharedInstance {
    if (_sharedInstance) {
        _sharedInstance = nil;
        _onceToken = 0;
    }
}

- (instancetype)init {
    self = [super init];
    return self;
}

- (void)dealloc {
    NSLog(@"ExampleSingleton SharedInstance Did Halted ");
}

在这个单例中,使用静态的全局指针_sharedInstance控制单例生命周期
把Pods式的数据初始化放在了sharedInstance函数中,保证只能执行一次.
使用类方法haltSharedInstance关闭单例
通过日志监控生命周期

关闭单例的原理是把静态的全局指针_sharedInstance置为nil,从而使内存地址的retainCount为0,让ARC自动释放掉内存空间,并且把静态指针_onceToken重新置为0,让下次执行shareInstance时可以再次初始化.

可不可以再作一点,让单例自己释放掉自己

开发过程中又遇到一个需求从手机读取通讯录并且把姓名转为小写拼音进行排序,由于5C以前的机型转换小写拼音特别卡,所以想使用一个资源池,不同的功能都可以来访问,读取转换的结果,但是如果我长期不来访问,感觉这个单例占着内存不释放很不爽,而且万一用户在程序运行期间更新了通讯录,不知道何时更新资源池中的数据

为了这个需求,于是出现了以下这个作死的单例,功能如下

单例创建可以被全局访问
单例可以收手动回收
如果10分钟(600秒)内没有操作接入单例,单例自己把自己释放掉

最终代码如下

@interface ExampleSingleton : NSObject
+ (instancetype)shareInstance;
+ (void)haltSharedInstance;
+ (void)resetTimer;
@end

static ExampleSingleton *_sharedInstance = nil;
static dispatch_once_t _onceToken;
static NSTimer *_timer = nil;

@implementation ExampleSingleton

+ (instancetype)shareInstance {
    dispatch_once(&_onceToken, ^{
        _sharedInstance = [[ExampleSingleton alloc] init];
        if(_sharedInstance) {
            //Initial Data
        }
        NSLog(@"ExampleSingleton ShareInstance Did Create %p",_sharedInstance);
    });
    NSLog(@"Access ExampleSingleton %p",_sharedInstance);
    [self resetTimer];
    return _sharedInstance;
}

+ (void)haltSharedInstance {
    NSLog(@"SharedInstance Will Halted");
    if (_sharedInstance) {
        _sharedInstance = nil;
        _onceToken = 0;
    }
}

+ (void)resetTimer {
    if (_timer.isValid) {
        [_timer invalidate];
        NSLog(@"SharedInstance Reset Timer");
    }
    _timer= [NSTimer scheduledTimerWithTimeInterval:600 target:self selector:@selector(haltSharedInstance) userInfo:nil repeats:NO];
}

- (void)dealloc {
    NSLog(@"SharedInstance Did Halted ");
}

- (instancetype)init {
    self = [super init];
    if (self) {    }
    return self;
}

作死过程中遇到的问题(可以不看,比较枯燥)

测试过程中十分钟改为10秒

第一版代码

+ (instancetype)shareInstance {
    dispatch_once(&_onceToken, ^{
        _sharedInstance = [[ExampleSingleton alloc] init];
    });
    _timer= [NSTimer scheduledTimerWithTimeInterval:10 target:self selector:@selector(timeEndHaltSharedInstance) userInfo:nil repeats:NO];
    return _sharedInstance;
}

- (void)timeEndHaltSharedInstance {
    NSLog(@"SharedInstance Will Halted By Time ");
    [[self class] haltSharedInstance];
}

第一版代码中,直接让_timer在shareInstance初始化,每次接入都重新初始化一次,这样上一次内存地址的_timer会被释放掉,然后执行halt函数.发现会Crash.原因是timeEndHaltSharedInstance是成员方法,类方法中的self是[self Class]类名,成员方法传给类名所以Crash.

第二版代码

+ (instancetype)shareInstance {
    dispatch_once(&_onceToken, ^{
        _sharedInstance = [[ExampleSingleton alloc] init];
    });
    _timer= [NSTimer scheduledTimerWithTimeInterval:10 target:_sharedInstance selector:@selector(timeEndHaltSharedInstance) userInfo:nil repeats:NO];
    return _sharedInstance;
}

把执行地址改变之后,用_sharedInstance代替self,可以把成员方法发送给成员.但是产生了一个问题,由于存在成员方法,每次创建的timer和_sharedInstance会互相retain,所以接入了多少次就需要等多少次才能最后释放.日志如下

2016-01-12 16:46:32.276 Learn[31993:6644441] Access ShareInstance 0x7ffefac07870
2016-01-12 16:46:34.644 Learn[31993:6644441] Access ShareInstance 0x7ffefac07870
2016-01-12 16:46:34.644 Learn[31993:6644441] Reset Timer
2016-01-12 16:46:36.154 Learn[31993:6644441] Access ShareInstance 0x7ffefac07870
2016-01-12 16:46:36.155 Learn[31993:6644441] Reset Timer
2016-01-12 16:46:42.279 Learn[31993:6644441] SharedInstance Did Halted By Time 
2016-01-12 16:46:44.645 Learn[31993:6644441] SharedInstance Did Halted By Time 
2016-01-12 16:46:46.156 Learn[31993:6644441] SharedInstance Did Halted By Time 
2016-01-12 16:46:46.156 Learn[31993:6644441] SharedInstance Did Halted

虽然最后总时间还是10秒,但是由于接入频率过高的时候,可能造成内存溢出,因为不能被回收的内存太多

第三版代码

+ (instancetype)shareInstance {
    dispatch_once(&onceToken, ^{
        _sharedInstance = [[ExampleSingleton alloc] init];
    });
    [_sharedInstance resetTimer];
    return _sharedInstance;
}
......
//其余代码和以上一样
......

- (void)resetTimer {
    if (_timer.isValid) {
        [_timer invalidate];
        NSLog(@"Reset Timer");
    }
    _timer= [NSTimer scheduledTimerWithTimeInterval:600 target:_sharedInstance selector:@selector(timeEndHaltSharedInstance) userInfo:nil repeats:NO];
}

第三版代码在每次重置前,查询是否存在计时器,有的话就使用invalidate函数释放掉旧的计时器.算是完整实现功能了

反思

可是改了这么久,发现绕了一个大弯,无非是想及时释放旧的计时器,从而防止内存溢出,关键在于,使用了成员方法,让计时器本身被_sharedInstance产生retain.所以就去尝试使用了类方法.

第四版代码

使用了类方法代替成员方法

+ (instancetype)shareInstance {
    dispatch_once(&_onceToken, ^{
        _sharedInstance = [[ExampleSingleton alloc] init];
    });
    _timer= [NSTimer scheduledTimerWithTimeInterval:10 target:self selector:@selector(haltSharedInstance) userInfo:nil repeats:NO];
    return _sharedInstance;
}

+ (void)haltSharedInstance {
    NSLog(@"SharedInstance Did Halted By Time ");
    if (_sharedInstance) {
        _sharedInstance = nil;
        _onceToken = 0;
    }
}

输出日志如下

2016-01-12 17:21:48.079 Learn[32311:6674061] access ShareInstance 0x7fd9f96533f0
2016-01-12 17:21:49.255 Learn[32311:6674061] access ShareInstance 0x7fd9f96533f0
2016-01-12 17:21:49.935 Learn[32311:6674061] access ShareInstance 0x7fd9f96533f0
2016-01-12 17:21:58.084 Learn[32311:6674061] SharedInstance Did Halted By Time 
2016-01-12 17:21:58.084 Learn[32311:6674061] SharedInstance Did Halted 
2016-01-12 17:21:59.258 Learn[32311:6674061] SharedInstance Did Halted By Time 
2016-01-12 17:21:59.939 Learn[32311:6674061] SharedInstance Did Halted By Time

发现如果使用类方法,发现scheduledTimerWithTimeInterval中的类方法不会对SharedInstance产生retain,使得第一个计时器到时间就会终止掉单例.说明旧的计时器还是没有被释放掉.

总结

所以说通过[_timer invalidate]手动释放计时器还是必须的
不能使用成员方法让SharedInstance的Retain增加,因为可能造成Retain数过高无法手动释放

所以才有了最终代码,打印日志如下

2016-01-12 17:34:22.452 Learn[32375:6683898] ExampleSingleton ShareInstance Did Create 0x7fa20a346e90
2016-01-12 17:34:22.453 Learn[32375:6683898] Access ShareInstance 0x7fa20a346e90
2016-01-12 17:34:23.403 Learn[32375:6683898] Access ShareInstance 0x7fa20a346e90
2016-01-12 17:34:23.403 Learn[32375:6683898] SharedInstance Reset Timer
2016-01-12 17:34:25.796 Learn[32375:6683898] Access ShareInstance 0x7fa20a346e90
2016-01-12 17:34:25.797 Learn[32375:6683898] SharedInstance Reset Timer
2016-01-12 17:34:35.797 Learn[32375:6683898] SharedInstance Will Halted
2016-01-12 17:34:35.797 Learn[32375:6683898] SharedInstance Did Halted

如何确定NSTimer是不是真的被释放了

因为[_timer invalidate]仅仅是让倒计时触发停止,是不是真的被释放了内存呢?如果没有释放,会不会造成内存溢出?

+ (void)resetTimer {
    if (_timer.isValid) {
        [_timer invalidate];
        _timer = nil;
        NSLog(@"SharedInstance Reset Timer");
    }
    //break point 此处打断点
    _timer= [NSTimer scheduledTimerWithTimeInterval:600 target:self selector:@selector(haltSharedInstance) userInfo:nil repeats:NO];
}

使用以上代码进行控制台调试lldb进行验证

2016-01-12 23:01:26.669 Learn[33017:6772455] ExampleSingleton ShareInstance Did Create 0x7ff378d10020
2016-01-12 23:01:26.670 Learn[33017:6772455] Access ExampleSingleton 0x7ff378d10020
(lldb) po _timer//1. timer未被初始化
 nil
(lldb) n
(lldb) po _timer//2. timer初始化成功 地址一
<__NSCFTimer: 0x7ff37b0028a0>

(lldb) po 0x7ff37b0028a0//3. 验证地址一内的内容
<__NSCFTimer: 0x7ff37b0028a0>

(lldb) c//4. 继续执行 第二次触发断点
2016-01-12 23:01:53.404 Learn[33017:6772455] Access ExampleSingleton 0x7ff378d10020
2016-01-12 23:01:53.404 Learn[33017:6772455] ExampleSingleton Reset Timer
(lldb) po 0x7ff37b0028a0 //5. 打印地址一,发现仅为地址,没有任何变量
140683717388448

(lldb) po _timer//6. 再次检查timer,没有任何指向
 nil
(lldb) n//7. 向下执行一行,进行初始化
(lldb) po _timer//8. 第二次初始化成功,地址二出现 
<__NSCFTimer: 0x7ff378e12a80>

(lldb) p 0x7ff378e12a80 //地址二的位置
(long) $7 = 140683681802880
(lldb) p 0x7ff37b0028a0//地址一的位置
(long) $8 = 140683717388448

发现如果进行无效后指向nil,第一次初始化的地址会被释放.使用上文中的最终版代码进行验证

2016-01-12 23:12:53.624 Learn[33048:6777254] ExampleSingleton ShareInstance Did Create 0x7ff4f041c980
2016-01-12 23:12:53.625 Learn[33048:6777254] Access ExampleSingleton 0x7ff4f041c980
(lldb) po _timer//1. timer未被初始化
 nil
(lldb) n
(lldb) po _timer//2. timer初始化成功 地址一
<__NSCFTimer: 0x7ff4f0514580>

(lldb) po 0x7ff4f0514580//3. 验证地址一内的内容
<__NSCFTimer: 0x7ff4f0514580>

(lldb) c //4. 继续执行 第二次触发断点
Process 33048 resuming
2016-01-12 23:13:19.084 Learn[33048:6777254] Access ExampleSingleton 0x7ff4f041c980
2016-01-12 23:13:19.084 Learn[33048:6777254] ExampleSingleton Reset Timer
(lldb) po 0x7ff4f0514580 //5. 打印地址一,发现变量未被释放
<__NSCFTimer: 0x7ff4f0514580>

(lldb) po _timer//6. 再次检查timer,发现指向的仍为地址一,仅仅是从新启动了倒计时
<__NSCFTimer: 0x7ff4f0514580>

经过验证发现,如果仅仅[_timer invalidate],静态指针指向的NSTimer并没有被释放,仅仅是停止了倒计时,下一次初始化时,还是在原地址,从新打开了新的倒计时.

Android设计模式总结
单例模式:饿汉单例模式：//饿汉单例模式懒汉单例模式： Double CheckLock(DCL)实现单例 Bu...
IOS单例模式的底层原理
单例介绍本文源码下载地址 1.什么是单例说到单例首先要提到单例模式，因为单例模式是单例存在的目的单例模式是一...
【设计模式】单例模式
单例模式常用单例模式：懒汉单例模式：静态内部类单例模式： Android Application 中使用单例模式：
2020-11-02-Spring单例 vs. 单例模式
Spring 单例不是 Java 单例。本文讨论 Spring 的单例与单例模式的区别。前言单例是 Sprin...
IOS学习笔记之单例
单例介绍 1.什么是单例说到单例首先要提到单例模式，因为单例模式是单例存在的目的单例模式是一种常用的软件设计模...
OC - 单例模式
导读：一、什么是单例模式二、单例的作用三、常见的单例类四、自定义单例类的方法一、什么是单例模式单例模式...
单例
单例单例宏
单例模式
特点单例类只有1个实例对象该单例对象必须由单例类自行创建单例类对外提供一个访问该单例的全局访问点结构单例...
关于java单例模式，这篇已经讲得很清楚了，建议收藏！
概念 java中单例模式是一种常见的设计模式，单例模式分三种：懒汉式单例、饿汉式单例、登记式单例三种。特点单例...
单例
iOS单例模式iOS之单例模式初探iOS单例详解