单例模式详解

单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。

1.单例模式的要点：

　　显然单例模式的要点有三个；一是某个类只能有一个实例；二是它必须自行创建这个实例；三是它必须自行向整个系统提供这个实例。

2.单例模式的优点：

　　1.实例控制：Singleton 会阻止其他对象实例化其自己的 Singleton 对象的副本，从而确保所有对象都访问唯一实例。

　　2.灵活性：因为类控制了实例化过程，所以类可以更加灵活修改实例化过程

 

IOS中的单例模式

　　在objective-c中要实现一个单例类，至少需要做以下四个步骤：
　　1、为单例对象实现一个静态实例，并初始化，然后设置成nil，
　　2、实现一个实例构造方法检查上面声明的静态实例是否为nil，如果是则新建并返回一个本类的实例，
　　3、重写allocWithZone方法，用来保证其他人直接使用alloc和init试图获得一个新实力的时候不产生一个新实例，
　　4、适当实现allocWitheZone，copyWithZone，release和autorelease。

下面用几种demo来演示以下

第一种

.h

+ (Singleton *)getInstance;

.m

+ (Singleton *)getInstance 

{

     static Singleton *sharedSingleton_ = nil;

     @synchronized(self) {

          if(sharedSingleton_ == nil){

             sharedSingleton_ = [NSAllocateObject([self class] ,0,NULL) init];

          }

     }

    return sharedSingleton_;

}

上面代码的实现是不严格的版本 在实际使用情况，可能会遇到发起调用的对象 不能以其分配方式实例化对象，否则，就会创建朵儿实例    加上下面的，重新加载了allocWithZone：保持了从Instance方法返回的单例对象，使用者哪怕使用alloc 时也会返回唯一实例 alloc 方法会先调用allocWithZone：创建对象。retain等内存管理的函数也被重载了，这样变得严格了

+(id)allocWithZone:(NSZone *)zone

{

      return [[self getInstance] retain];

}

- (id) copyWithZone:(NSZone*)zone
 {
   return self;
 }
 
 - (id) retain
 {
   return self;
 }
 
 - (NSUInteger) retainCount
 {
   return NSUIntegerMax; 
 }
 

//oneway用在分布式对象的API，这些API可以在不同的线程，甚至是不同的程序。oneway关键字只用在返回类型为void的消息定义中， 因为oneway是异步的，其消息预计不会立即返回。
 -(oneway void)release
 {
   [super release];
 }
 
 - (id) autorelease
 {
   return self;
 }
 

第二种

启用ARC

static RootViewController* sharedRootController = nil;
 
+(RootViewController *) sharedController{
    @synchronized(self){
        if (sharedRootController == nil) {
           sharedRootController = [[self alloc] init];
        }
    }
    return  singleController;
}
单例模式的优缺点
时间和空间
懒汉式是典型的时间换空间，就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断时间。如果一直没有人使用，就不会创建实例，则节省内存空间
饿汉式是典型的空间换时间，当类加载的时候创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要判断了，节省运行时间
线程安全
从线程安全上讲，不加同步的懒汉式是线程不安全的。比如两个线程，同时调用getInsance方法，就可能导致并发问题
饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载的时候不会发生并发
如何实现懒汉式线程的安全
只要加上synchronized即可
public static synchronized Singleton getInstance(){}
这样一来，会降低整体的访问速度，而且每次都要判断，那么有没有更好的实现方式
双重检查加锁
所谓的双重加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法后，检查实例是否存在，如果不存在进入下面的同步块，这是第一重检查，进入同步块，再次检查实例的是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次，从而减少多次在同步情况下判断所浪费的时间
双重检查加锁机制的实现会使用一个关键字volatile，他得意思是，被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存，从而确保多个线程能正确的处理该变量
public class Singleton{
// 对保存实例的变量添加volatile的修饰
   private volatile static Singleton instance = nil;
   private Singleton(){
   }
   public static Singleton getInstance(){
   // 先检查实例是否存在，如果不存在进入下面的同步块
      if(instance  == null){
       // 同步块,线程安全地创建
        synchronized(Singleton.class){
         // 再次检查实例是否存在，如果不存在真正的创建实例
          if (instance == null){
              instance = new Singleton();
          }
        }
       return instance;
      }
   }
这种实现方式既可以实现线程安全地创建实例，又不会对线程造成太大影响，它只在第一次创建实例的时候同步，以后就不要同步了，从而加快了运行速度
第三种
例子：为RootViewController创建一个单例函数：

static RootViewController *shareRootViewController = nil;
+(RootViewController *)sharedController{
        @synchronized(self){
                if(shareRootViewController == nil){
                        shareRootViewController = [[[self alloc] init] autorelease];
                }
        }
        return shareRootViewController;
}

+(id)allocWithZone:(NSZone *)zone{
        @synchronized(self){
                if (shareRootViewController == nil) {
                   shareRootViewController = [super allocWithZone:zone];
                    return  shareRootViewController;
                }
            }
        return nil;
}

NSZone： 简单来说可以把它想象成一个内存池，alloc或者dealloc这些操作都是在这个内存池中操作的，cocoa总是会分配一个默认的nsZone，任何 默认内存操作都是在这个zone上进行的，使用默认zone存在缺陷，因为他是全局范围的，频繁使用会导致内存的碎片化，尤其是大量的alloc和 dealloc的时候，性能上会受到一定影响。因为你完全可以自己生成一个zone并将alloc，copy这些限制在这个zone中。

第四种

线程控制 （个人认为最好的一种）

+ (Singleton *)sharedInstance
{
    static Singleton *_instance;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[self alloc] init];
    });
    return _instance;
}