iOS 单例类详解（二）

单例一般作为：工具类

单例命名：一般情况下如果一个类是单例，那么就要提供一个类方法用于快速创建单例对象，而且这个类方法的名称是有一定的规则：share + 类名称 / default + 类名称

单例的应用十分普遍，单例模式使一个类只有一个实例，易于供外界访问，方便控制实例个数,节约系统资源.

应用程序中用到的单例 : 背景音乐，音效管理等。

OC中的常见单例:
如：UIApplication,
NSNotificationCenter,
NSUserDefaults,
NSFIleManager。

一、ARC（自动引用计数模式）中实现单例的步骤: 创建单例的步骤:

1.定义一个全局的静态变量 _instance，用来记录“第一次”被实例化出来的对象
2.重写allocWithZone方法，此方法是为对象分配内存空间必须会被调用的一个方法！因此，在此方法里面使用“dispatch_once”，能够保证在多线程中，_instance也只能被“分配”一次空间. 并调用super allocWithZone。
3.定义一个sharedXXX “类” 方法，用来获取单例. 在此方法中也调用 dispatch_once, 实例化_instance 保证使用类方法调用的对象，只会被初始化一次！也方便其他使用单例的对象调用此单例.
注释：如果不考虑copy& MRC，以上三个步骤即可！(这里不知道你会不会问那什么情况下要考虑copy呢？)
----可选---------------------------------------
*4.如果要支持copy，则需要:
（1）先遵守NSCopying协议，重写copyWithZone
（2）在copyWithZone方法中，直接返回_instance即可。

tips：
一般的写法(懒汉式, 饿汉式, 加锁):
if(!_instance)_instance=[[RockShareTool alloc]init];
return_instance;
懒汉式是线程不安全的.因此实际中不这么写. 还有饿汉式,加锁等.
但是OC中有其自己的写法.需要结合其对象生命周期的一些方法来写单例.

为什么要使用dispatch_one? :

防止多线程同时进来,就相当与Java单例中的加锁机制,保证只被实例化一次. 但这里使用的不是@synchronized(){}, 是类似互斥锁的东西, 但比他的性能高.

ARC中实现单例的代码如下：

.h 
@interface HttpdnsIPListObject: NSObject
// 我的修改  启动 ip && 服务 ip
@property (nonatomic, strong) NSMutableArray *startIPList;
@property (nonatomic, strong) NSMutableArray *serverIPlist;

+ (HttpdnsIPListObject *)sharedIPListObject;

@end

.m

@implementation HttpdnsIPListObject
//第1步: 存储唯一实例
static HttpdnsIPListObject * _iPListObject = nil;

//第2步: 分配内存空间时都会调用这个方法. 保证分配内存alloc时都相同.
+ (id)allocWithZone:(struct _NSZone *)zone  {
//调用dispatch_once保证在多线程中也只被实例化一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _iPListObject = [super allocWithZone:zone];
    });
 return _iPListObject;
 }
//第3步: 保证init初始化时都相同
+ (instancetype)sharedIPListObject {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _iPListObject = [[HttpdnsIPListObject alloc] init];
    });
    return _iPListObject;
}

//第4步: 保证copy时都相同
- (id)copyWithZone:(NSZone *)zone {
     return _iPListObject;
}

@end

测试代码如下（打印单例对象的地址都相同）:

-(void)viewDidLoad{
        //实例化一个类的几种方法. 单例就是要保证实例化出来的类是同一个类
        //1.alloc init方法. 一般不这么来调用单例.
        RockShareTool *t1 = [[RockShareTool alloc] init];
        RockShareTool *t2 = [[RockShareTool alloc] init];
        //2.类方法
        RockShareTool *t3 = [RockShareTool sharedTool];
        //3.copy
        RockShareTool *t4 = [t3 copy];
        NSLog(@"%@ %@ %@ %@", t1, t2, t3, t4);
    }

二、MRC中运用单例:

因为单例对象是用 static 标记过的, 因此存放在静态区.
所以在MRC中不需要由程序员去管理,因此要去覆盖一些内存管理的方法.
实现部分与ARC一致,只需要覆盖一些MRC中内存管理的方法:

- (id)retain.  单例中不需要增加引用计数器.returnself.
- (id)autorelease.  只有堆中的对象才需要.单例中不需要.returnself.   
- (NSUInteger)retainCount. (可写可不写,防止引起误解).单例中不需要修改引用计数，返回最大的无符号整数即可.return UINT_MAX;
- (oneway void)release.不需要release.直接覆盖,什么也不做.

操作如下：

#import "RockShareTool.h"     
@implementation RockShareTool   
static RockShareTool *_instance;
    
     + (id)allocWithZone:(struct _NSZone *)zone {
         static dispatch_once_t onceToken;
         dispatch_once(&onceToken, ^{
             _instance = [super allocWithZone:zone];
         });
         return _instance;
     }
    
    + (instancetype)sharedTool {
        static dispatch_once_t onceToken;
        dispatch_once(&onceToken, ^{
            _instance = [[RockShareTool alloc] init];
        });
        return _instance;
    }
    
    - (id)copyWithZone:(NSZone *)zone {
        return _instance;
    }
    
     //可以看出实现部分与ARC一致，下面是MRC中需要覆盖的方法
     #pragma mark - MRC中需要覆盖的方法
     //不需要计数器+1
    - (id)retain {
        return self;
    }
    
    //不需要. 堆区的对象才需要
    - (id)autorelease {
        return self;
    }
    //不需要
    - (oneway void)release {
    }  
    
    //不需要计数器个数. 直接返回最大无符号整数  
    - (NSUInteger)retainCount {  
        return UINT_MAX;  //参照常量区字符串的retainCount  
    }  
    @end

三、ARC 与 MRC的整合

单例模式的作用可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问，从而方便地控制了实例个数，并节约系统资源。单例模式在ARC\MRC环境下的写法有所不同，需要编写2套不同的代码，整合是为了方便单例既能在ARC中使用，又能在MRC中使用。而不必去修改单例中的方法。具体做法是使用宏定义：（判断是否是ARC环境，是的话就省略内存管理的方法）

#if !__has_feature(objc_arc)

MRC中内存管理的方法放在这个地方

endif

代码如下：

// ==== ARC / MRC 整合 =====================
 #pragma mark - MRC中需要覆盖的方法, ARC与MRC的整合
 #if !__has_feature(objc_arc)
    - (id)retain {
        return self;
    }
    
    - (id)autorelease {
        return self;
    }
    
    - (oneway void)release {
    }
    
    - (NSUInteger)retainCount {
        return UINT_MAX;
    }
    #endif

iOS 实现单例写法

static id _instance;
    //  alloc方法内部会调用这个方法
    + (id)allocWithZone:(struct _NSZone *)zone
    {
        if (_instance == nil) { // 防止频繁加锁
            @synchronized(self) {
                if (_instance == nil) { // 防止创建多次
                    _instance = [super allocWithZone:zone];
                }
            }
        }
        return _instance;
    }
    
    + (instancetype)sharedTool
    {
        if (_instance == nil) { // 防止频繁加锁
            @synchronized(self) {
                if (_instance == nil) { // 防止创建多次
                    _instance = [[self alloc] init];
                }
            }
        }
        return _instance;
    }
    
    - (id)copyWithZone:(NSZone *)zone
    {
        return _instance;
    }
    // 如果是非ARC环境需要加上以下代码
    // 重写release对象不会被释放掉
    - (oneway void)release { }
    // retain直接返回对象
    - (id)retain { return self; }
    // 读取对象ratainCount返回1
    - (NSUInteger)retainCount { return 1;}
    // 执行自动释放操作返回self
    - (id)autorelease { return self;}

iOS 单例类详解 （二）