IOS 单例模式总结

在项目中我们经常会使用到单例，今天我个人就说说我眼中的单例。
首先说一说什么是单例呢？使用单例的好处有哪些呢？
单例是iOS中常用的一种设计模式。单例模式是一个类在系统中只用一个实例对象。通过全局的一个入口点对这个实例对象进行访问；
单例的好处：
1、提供了对唯一实例的受控访问。
2、由于在系统内存中只存在一个对象，因此可以节约系统资源，对于一些需要频繁创建和销毁的对象单例模式无疑可以提高系统的性能。
单例分为两种：
第一、完全意义上的单例：就是无论我们是alloc、copy、还是使用shared方法创建出来的单例对象都是一个；
非完全意义上的单例：就是我们alloc、copy、还是使用shared方法创建出来的单例对象都是不相同（这种方式其实也就失去了单例的特性，我们不会使用，但是新手学习的时候还是可能出现的）。
第二：线程安全的单例：就是多个线程同时访问的时候不会出现多个对象；
非线程安全的单例：就是多个线程同时访问的时候可能会出现多个对象。
当然两两是可以结合的，我们一般使用的就是线程安全完全意义上的单例
下面我们就说一下几种单例。
首先我们先定义一个类TRDataManager
其次我们就来说说几种单例了。
1、我们不用的非完全意义上的单例：
.h文件中我们声明一个方法+ (instancetype)sharedDataManager;
.m文件中实现:

  static TRDataManager *_dataManager = nil;
  + (instancetype)sharedDataManager{
    if (nil == _dataManager) {
     _dataManager = [[TRDataManager alloc]init];
    }
    return _dataManager;
  }

在外面访问
TRDataManager *dataManager = [TRDataManager sharedDataManager];
这是初学者经常使用的方法，那么有什么不好的呢，假如我们这样声明变量
TRDataManager *dataManager = [[TRDataManager alloc]init];那么我们得到的就不是单例了，就是一个新的对象，这样就失去了单例的作用。
2、完全意义上的单例：
.h文件中我们遵守<NSCopying>协议,然后我们声明一个方法+ (instancetype)sharedDataManager;
.m文件中实现:

  static TRDataManager *_dataManager = nil;
  + (instancetype)sharedDataManager{
   if (nil == _dataManager) {
    _dataManager = [[TRDataManager alloc]init];
       }
      return _dataManager;
   }
 //重写alloc方法 或者底层allocWithZone
   + (instancetype)allocWithZone:(struct _NSZone *)zone {
   if (_dataManager == nil) {
    _dataManager = [super allocWithZone:zone];
    }
    return _dataManager;
   }
   //当copy当前类型的对象时候 ，返回唯一的单例对象
  - (id)copyWithZone:(NSZone *)zone {
     return _dataManager;
  }

alloc会调用allocWithZone方法，这样无论我们是使用alloc、copy、还是使用shared方法都只会创建一个对象，但是这种方式也是不安全的
3、非线程安全的单例：
例如：2中就是这样的样式，如果有多个线程同时访问shared方法，可能就会出现在访问的时候_dataManager对象都是空的，那样就会创建多个对象了。
4、线程安全的单例：
就是使用GCD技术或线程锁的方法将线程保护起来，保证方法只执行一次
.h文件中我们声明一个方法+ (instancetype)sharedDataManager;
.m文件中实现:

 static TRDataManager *_dataManager = nil;
 + (instancetype)sharedDataManager {
        //1、创建一个静态的一次性任务对象
        static dispatch_once_t onceToken;
       //2、调用一次性任务方法
         dispatch_once(&onceToken, ^{
        //创建单例对象
       _dataManager = [[TRDataManager alloc]init];
         });
          //3、返回单例对象
       return _dataManager;
   }

我们会经常使用线程安全完全意义上的单例，那么如何来实现呢？
两种方法：
第一种：
.h文件中我们遵守<NSCopying>协议,然后我们声明一个方法+ (instancetype)sharedDataManager;
.m文件中实现:

static TRDataManager *_dataManager = nil;
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
 static dispatch_once_t once;
    dispatch_once(&once , ^{
        _dataManager = [super allocWithZone:zone];
    });
    return _dataManager;
}
+ (instancetype)sharedDataManager {
if (nil == _dataManager) {
    _dataManager = [[TRDataManager alloc]init];
}
   return _dataManager;
}
- (id)copyWithZone:(NSZone *)zone {
  return _dataManager;
 }

第二种：
.h文件中我们遵守<NSCopying>协议,然后我们声明一个方法+ (instancetype)sharedDataManager;
.m文件中实现:

static TRDataManager *_dataManager = nil;
+ (void)initialize {
if (self == [TRDataManager class]) {
    _dataManager = [TRDataManager allocWithZone:nil];
    NSLog(@"安全");
  }
}
- (id)copyWithZone:(NSZone *)zone {
return _dataManager;
}
+ (instancetype)alloc {
return _dataManager;
}
+ (instancetype)sharedSecondPerson {
return _dataManager;
}

我们也可能在一个工程中使用多个单例对象，那么这种方式复用性就不太好了，我们怎么使用呢，我们一般采用宏定义的方式，新建一个空的文件，然后写入下面的代码，如下：

 #define singleton_interface(class) + (instancetype)shared##class;\
#define singleton_implementation(class)\
 static class *_instance; \
 + (id)allocWithZone:(struct _NSZone *)zone \
 { \
   static dispatch_once_t onceToken; \
  dispatch_once(&onceToken, ^{ \
    _instance = [super allocWithZone:zone]; \
   }); \
    \
       return _instance; \
    } \
  + (instancetype)shared##class \
   { \
     if (_instance == nil) { \
        _instance = [[class alloc] init]; \
     } \
    \
        return _instance; \
    }\
  -(id)copyWithZone:(NSZone *)zone\
     {\
       return _instance;\
    }\

大概就这些了，希望大家能提出宝贵的意见，可以给我留言，也可以发邮件到我的邮箱：namezyqyx@163.com
谢谢大家，如果你有更好的想法或文章请告知，不胜感激。