iOS中单例使用以及优缺点

2023-04-16 本文已影响0人 Edviin_2de8

一、单例介绍

单例模式：单例模式，属于创建类型的一种常用的软件设计模式。通过单例模式的方法创建的类在当前进程中只有一个实例。

为了我们能更好的理解单例模式，我列举以下几个cocoa框架中常用的单例：

1.UIApplication：应用程序。一个UIApplication对象就代表着一个应用程序，每个应用程序有且仅有一个UIApplication对象，开发中最常用的是使用它的openURL函数来跳转到其他应用程序，通过 [UIApplication sharedApplication] 类方法可以获得。

2.NSNotificationCenter：通知中心。iOS中的通知中心是一种消息广播，采用观察者模式和单例模式，一个应用有且仅有一个通知中心。通过 [NSNotificationCenter defaultCenter] 类方法可以获得。

3.NSFileManager：文件管理器。它是iOS文件系统的接口，用来创建、修改、访问文件。一个应用有且仅有一个文件管理器。通过 [NSFileManager defaultManager] 类方法可以获得。

4.NSUserDefaults：用户偏好设置。它主要用来存储简单的键值对数据，数据持久化最简单和基础的一种方案。通过 [NSUserDefaults standardUserDefaults] 类方法可以获得。

5.NSURLCache：URL缓存。通过将NSURLRequest对象映射到NSCachedURLResponse对象来实现对URL加载请求的响应的缓存。通过 [NSURLCache sharedURLCache] 类方法可以获得。

1.1 单例模式的要点

1.只能有一个实例；
2.它必须自行创建这个实例；
3.它必须自行向整个系统提供这个实例。

从具体实现角度来说，是以下三点：

1.单例模式的类只提供私有的构造函数；
2.类定义中含有一个该类的静态私有对象（实例）；
3.提供一个静态的公有函数用于创建或获取它本身的静态私有对象（实例）。

1.2 单例模式的优点

1.实例控制：单例可以保证系统中该类有且仅有一个实例，确保所有对象都访问这个唯一实例；
2.灵活性：因为类控制了实例化的过程，所以类可以灵活更改实例化过程；
3.节省开销：因为只有一个实例，所以减少内存开发和系统的性能开销。

1.3 单例模式的缺点

1.由于单例模式中没有抽象层，可扩展性比较差。
2.实例一旦被创造，对象指针保存在静态区，那么在堆区分配的空间只有在App结束后才会被释放；
3.单例类职责过重，在一定程度上违背了“单一职责原则”。
4.滥用单例会带来一些负面问题，比如，单例会隐性地让毫不相关的类产生耦合等问题。

二、单例的实现

单例的实现重点就是防止在外部调用的时候出现多个不同的实例，也就是说要从创建的方式入手禁止出现多个不同的实例。

主要做到以下几点：

1.防止调用 [[A alloc] init] 引起错误

2.防止调用 new 引起错误

3.防止调用 copy 引起错误

4.防止调用 mutableCopy 引起错误

2.1 典型的单例写法

static id sharedMyManager;
 +(id)shareThemeManager{
     if(sharedThemeManager == nil){
              shareMyManager = [[self alloc]init];
     }
   return sharedMyManager;
 }

缺点：无法保证多线程情况下只创建一个对象。适用于只有单线程。

2.2 加锁的写法

 static Singleton *_sharedSingleton = nil;

+(instancetype)sharedSingleton {
    @synchronized(self){   //加锁，保证多线程下也只能有一个线程进入
        if (! _sharedSingleton) {
            _sharedSingleton = [[self alloc] init]; 
        } 
    } 
    return _sharedSingleton;
 }

2.3 GCD写法【常用】

2.3.1 重写父类方法

static Singleton *_sharedSingleton = nil;

+ (instancetype)sharedSingleton
  {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        // 不能再使用 alloc 方法
        // 因为已经重写了 allocWithZone 方法，所以这里要调用父类的分配空间的方法
        _sharedSingleton = [[super allocWithZone:NULL] init];
    });
    return _sharedSingleton;
  }

// ②、防止 [[A alloc] init] 和 new 引起的错误。因为 [[A alloc] init] 和 new 实际是一样的工作原理，都是执行了下面方法

+ (instancetype)allocWithZone:(struct _NSZone *)zone
  {
    return [Singleton sharedSingleton];
  }

// ③、NSCopying 防止 copy 引起的错误。当你的单例类不遵循 NSCopying 协议，外部调用本身就会出错.

- (id)copyWithZone:(nullable NSZone *)zone
  {
    return [Singleton sharedSingleton];
  }

// ④、防止 mutableCopy 引起的错误，当你的单例类不遵循 NSMutableCopying 协议，外部调用本身就会出错.

- (id)mutableCopyWithZone:(nullable NSZone *)zone 
  {
    return [Singleton sharedSingleton];
  }
  dispatch_once 主要是根据 onceToken 的值来决定怎么去执行代码。

1.当 onceToken = 0 时，线程执行 dispatch_once 的 block 中代码；

2.当 onceToken = -1 时，线程跳过 dispatch_once 的 block 中代码不执行；

3.当 onceToken 为其他值时，线程被阻塞，等待 onceToken 值改变。

当线程调用 shareInstance，此时 onceToken = 0，调用 block 中的代码，此时 onceToken = 其他值。当其他线程再调用 shareInstance 方法时，onceToken为其他值，线程阻塞。当 block 线程执行完 block 之后，onceToken = -1，其他线程不再阻塞，跳过 block。下次在调用 shareInstance 时， block 已经为 -1，直接跳过 block。

2.3.2 禁止外部调用

这种写法还蛮简单好用的~

.h 文件

- (instancetype)init NS_UNAVAILABLE;

+ (instancetype)new NS_UNAVAILABLE;

- (id)copy NS_UNAVAILABLE;
- (id)mutableCopy NS_UNAVAILABLE;

.m 文件

static Singleton *_sharedSingleton = nil;

+ (instancetype)sharedSingleton
  {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
          _sharedSingleton = [[self alloc] init];  // 要使用 self 来调用
    });
    return _sharedSingleton;
  }

当运行 init 或者 new 时，会报错 'init' is unavailable 或者 'new' is unavailable。

2.3.3 宏定义写法

写成宏是比较方便也比较常见的一种：

#define MY_SINGLETON_DEF(_type_) + (_type_ *)sharedInstance; \
+(instancetype) alloc __attribute__((unavailable("call sharedInstance instead"))); \
+(instancetype) new __attribute__((unavailable("call sharedInstance instead"))); \
-(instancetype) copy __attribute__((unavailable("call sharedInstance instead"))); \
-(instancetype) mutableCopy __attribute__((unavailable("call sharedInstance instead"))); \
#define MYY_SINGLETON_IMP(_type_) + (_type_ *)sharedInstance{ \
static _type_ * sharedInstance = nil; \
static dispatch_once_t onceToken; \
dispatch_once(&onceToken, ^{ \
sharedInstance = [[super alloc] init]; \
}); \
return sharedInstance; \
}

用法也很简单：

//引用
@interface MYSingleton : NSObject
MY_SINGLETON_DEF(MYSingleton);
@end
//实现
@implementation MYSingleton
MY_SINGLETON_IMP(MYSingleton);
@end

2.4 免锁写法

static Singleton *_sharedSingleton = nil;

+ (instancetype)sharedSingleton {
  static BOOL initialized = NO;
  if (initialized == NO){
      initialized = YES;
      _sharedSingleton = [[self alloc] init];
  }
  return _sharedSingleton;
   }

1,2,4三种写法还需将 init new 重写或禁用才算完整哦~

三、单例的滥用

上面关于单例的部分，写的太好了，所以我把全文搬运过来了

原文地址：iOS 单例模式详解/避免滥用单例

有兴趣的可以去看看