设计模式-单例

作者: 羊妞麻麻 | 来源:发表于2016-12-16 16:05 被阅读34次

单例模式Java篇
python中OOP的单例
单例
python 单例
2018-04-08php实战设计模式
设计模式第二篇、单例设计模式
设计模式 - 单例模式
2、创建型设计模式-单例设计模式
设计模式之单例模式
设计模式

面试的时候，经常会被问到一些问题。大致总结一下思路，用来回答面试关的问题。

比如面试官会问到单例。可以从以下几点出发，来回答问题。争取问题的主动性。what how why的原则。来具体问题具体分析，透过现象看本质。

1.什么是单例？
2.为什么要用单例？它的优缺点是什么？
3.单例解决了什么问题？你的项目中哪里用到了单例？
4.单例怎么用？
5.怎么创建单例？
6.怎么销毁单例？
7.写单例的时候需要注意什么问题？
8.iOS源代码中哪里用到了单例？举例说明。

我想只要面试官问的所有的问题，你往这个上面套就行了。这样才能在面试官还没有问的情况下回答了他所有要问的问题，争取主动权在自己手里。

1.什么是单例
在开发过程中，为了保证在整个生命周期内，只会创建一个类的实例对象，只要程序不被杀死，该实例对象不被释放，会一直存在。

2.为什么要用单例，单例的作用,优缺点？
1）比如在APP开发中我们可能在任何地方都会使用到用户信息，那么我们就可以登录的时候就把用户信息存放在一个文件里面，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象在通过这个单例对象获取这些配置的信息。

+ (instancetype)sharedDataStore
{
    static NMAccountDataStore *dataStore = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        dataStore = [NMAccountDataStore new];
    });
    return dataStore;
}

这个类里面存了currentUserInfo结构的用户所有信息，比如姓名，电话，email，性别，登录次数，token，时间戳等。
同时还可以存一个字典，里面存放当前或者所有的用户。
当你在其他类里面想用这个类里面的数据的时候可以这样获取：

//获得当前的用户信息
- (NMAccountUserInfo *)currentUserInfoRef
{
    return [[NMAccountDataStore sharedDataStore] currentUserInfo];
}
//获得所有的用户
- (NSMutableDictionary *)allUserDictRef
{
    return [[NMAccountDataStore sharedDataStore] allUserDict];
}

2）比如我们用的本地音乐，用来播放音乐，而这个音乐只能有一个实例来播放声音。
3）比如数据库，一个程序中只能保证一个数据库在操作，避免同时操作数据库而造成数据错误的情况。FMDB里面就是用的单例。

+ (FMDBTools *)singletonDatabase {
   static FMDBTools *sharedManager;
   static dispatch_once_t onceToken;
   dispatch_once(&onceToken, ^{
       sharedManager = [[FMDBTools alloc] init];
   });
   return sharedManager;
}

在你创建数据库的时候就可以这样直接获取这个实例

屏幕快照 2016-12-16 下午1.49.07.png

单例模式的优缺点
1、时间和空间

比较上面写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。

饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。

下面介绍一下创建单例的方法，具体有两种，先讲一下第一种。
GCD的方式创建单例。

+ (instancetype)sharedDataStore
{
    //dispatch_once不仅意味着代码仅会被运行一次，而且还是线程安全的
    static NMAccountDataStore *dataStore = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        dataStore = [NMAccountDataStore new];
    });
    return dataStore;
}

互斥锁的方式

+ (instancetype)singletonController
{
    static NMAccountDataStore *_singletonDataStore = nil;
    @synchronized (self) {
        if (_singletonDataStore == nil) {
            _singletonDataStore = [[NMAccountDataStore alloc] init];
        }
    }
    return _singletonDataStore;
}

以上就是创建单例的两种方式，那么写单例的时候需要注意什么呢？两种创建方式有什么区别吗？

假设此时有两条线程：线程1和线程2，都在调用shareInstance方法来创建单例，那么线程1运行到if (_instance == nil)出发现_instance = nil,那么就会初始化一个_instance，假设此时线程2也运行到if的判断处了，此时线程1还没有创建完成实例_instance，所以此时_instance = nil还是成立的，那么线程2又会创建一个_instace。

此时就创建了两个实例对象，导致问题。
解决办法就是通过GCD的dispatch_once保证程序在运行的过程中只会被运行一次。
或者使用互斥锁。当线程执行shareInstance方法，那么可以使用synchronize增加一把锁，等这个线程的任务完成之后，才被唤醒。从而保证只有一个实例被创建。

区别：
但是互斥锁会影响性能，所以最好使用GCD的dispatch方法。因为加锁会有一定的系统开销， Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。

下面的截图可以看出，无论你创建了多少个实例变量，他的内存只是唯一的一个。

NMSingletonController *singleton1 = [NMSingletonController sharedInstance]; 
NMSingletonController *singleton2 = [NMSingletonController sharedInstance];
NMSingletonController *singleton3 = [[NMSingletonController alloc] init];
     NSLog(@"singleton1 内存地址%@ singleton2的内存地址 c%@ singleton3的内存地址 %@",singleton1,singleton2,singleton3);

singleton1 内存地址
<NMSingletonController: 0x600000004e50>
singleton2的内存地址
<NMSingletonController: 0x600000004e50>
singleton3的内存地址
<NMSingletonController: 0x600000004e50>

为了防止别人不小心利用alloc/init方式创建示例，也为了防止别人故意为之，我们要保证不管用什么方式创建都只能是同一个实例对象，这就得重写另一个方法，要在创建单例的类里面完成如下代码。

+ (id)allocWithZone:(struct _NSZone *)zone
{
    static dispatch_once_t once;
    dispatch_once(&once, ^{
        _singletonController = [super allocWithZone:zone];
    });
    
    return _singletonController;
}

- (id)copyWithZone:(NSZone *)zone  
{  
    return _instace;  
}

一般我们的类里肯定都会有一些属性，然后我就添加了两个property：
@property (assign, nonatomic) int height;
@property (strong, nonatomic) NSObject *object;
@property (strong, nonatomic) NSMutableArray *arrayM;

而一些对象类的初始化，或者基础类型的默认值设置都是在init方法里，就像这样：

- (instancetype)init
{
    self = [super init];
    if (self) {
        _height = 10;
        _object = [[NSObject alloc] init];
        _arrayM = [[NSMutableArray alloc] init];
    }
    return self;
}

我重写了该类的description方法：

- (NSString *)description
{
    NSString *result = @"";
    result = [result stringByAppendingFormat:@"<%@: %p>",[self class], self];
    result = [result stringByAppendingFormat:@" height = %d,",self.height];
    result = [result stringByAppendingFormat:@" arrayM = %p,",self.arrayM];
    result = [result stringByAppendingFormat:@" object = %p,",self.object];
    return result;
}

可以看到，尽管使用的是同一个示例，可是他们的property值却不一样。

因为尽管没有为示例重新分配内存空间，但是因为又执行了init方法，会导致property被重新初始化。

所以我们需要修改单例的实现。

第一种：
可以将property的初始化或者默认值设置放到dispatch_once 的block内部：

static HLTestObject *instance = nil;
+ (instancetype)sharedInstance
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[[self class] alloc] init];
        instance.height = 10;
        instance.object = [[NSObject alloc] init];
        instance.arrayM = [[NSMutableArray alloc] init];
    });
    return instance;
}

第二种：

static HLTestObject *instance = nil;
+ (instancetype)sharedInstance
{
    return [[self alloc] init];
}
- (instancetype)init
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [super init];
        instance.height = 10;
        instance.object = [[NSObject alloc] init];
        instance.arrayM = [[NSMutableArray alloc] init];
    });
    return instance;
}

单例的销毁：

/*
 方法一
 */
+ (void)attemptDealloc
{
    _singletonController = nil;
}

/*
 方法二
 只有将once置成0,GCD才会认为它从未执行过.它默认为0.这样才能保证下次再次调用shareInstance的时候,再次创建对象.
 */
+ (void)attemptDealloc
{
    once = 0;
    _singletonController = nil;
}

iOS SDK中哪里用到了单例？
单例类的应用贯穿于整个iOS的SDK中。例如，UIApplication类有一个方法叫sharedApplication，从任何地方调用这个方法，都将返回与当前正在运行的应用程序相关联的UIApplication实例。
除了这个，NSNotificationCenter(消息中心) 、NSFileManager(文件管理) 、 NSUserDefaults(持久化存储数据) 、NSURLCache(请求缓存)、NSHTTPCookieStorage(应用程序cookies池)都是系统单例；

单例类保证了应用程序的生命周期中有且仅有一个该类的实例对象，而且易于外界访问。