iOS 單例模式

沒原創(chuàng)_去搜索 2015-06-23

展開全文

創(chuàng)建一個單例很多辦法。我先列舉一個蘋果官方文檔中的寫法。

[cpp] view plain copy

static AccountManager *DefaultManager = nil;
+ (AccountManager *)defaultManager {
if (!DefaultManager) DefaultManager = [[self allocWithZone:NULL] init];
return DefaultManager;
}

當然，在iOS4之后有了另外一種寫法：

[cpp] view plain copy

+ (AccountManager *)sharedManager
{
static AccountManager *sharedAccountManagerInstance = nil;
static dispatch_once_t predicate;
dispatch_once(&predicate, ^{
sharedAccountManagerInstance = [[self alloc] init];
});
return sharedAccountManagerInstance;
}

該寫法來自 objcolumnist，文中提到，該寫法具有以下幾個特性：

1. 線程安全。

2. 滿足靜態(tài)分析器的要求。

3. 兼容了ARC

然后我還有點好奇的是dispatch_once,這個函數(shù)，沒見過啊。

于是就到官方的文檔里找找看，是怎么說的。

下面是官方文檔介紹：

dispatch_once

Executes a block object once and only once for the lifetime of an application.

void dispatch_once(

dispatch_once_t *predicate,

dispatch_block_t block);

Parameters

predicate

A pointer to a dispatch_once_t structure that is used to test whether the block has completed or not.

block

The block object to execute once.

Discussion

This function is useful for initialization of global data (singletons) in an application. Always call this function before using or testing any variables that are initialized by the block.

If called simultaneously from multiple threads, this function waits synchronously until the block has completed.

The predicate must point to a variable stored in global or static scope. The result of using a predicate with automatic or dynamic storage is undefined.

Availability

Available in iOS 4.0 and later.

Declared In

dispatch/once.h

我們看到，該方法的作用就是執(zhí)行且在整個程序的聲明周期中，僅執(zhí)行一次某一個block對象。簡直就是為單例而生的嘛。而且，有些我們需要在程序開頭初始化的動作，如果為了保證其，僅執(zhí)行一次，也可以放到這個dispatch_once來執(zhí)行。

然后我們看到它需要一個斷言來確定這個代碼塊是否執(zhí)行，這個斷言的指針要保存起來，相對于第一種方法而言，還需要多保存一個指針。

方法簡介中就說的很清楚了：對于在應用中創(chuàng)建一個初始化一個全局的數(shù)據(jù)對象（單例模式），這個函數(shù)很有用。

如果同時在多線程中調(diào)用它，這個函數(shù)將等待同步等待，直至該block調(diào)用結束。

這個斷言的指針必須要全局化的保存，或者放在靜態(tài)區(qū)內(nèi)。使用存放在自動分配區(qū)域或者動態(tài)區(qū)域的斷言，dispatch_once執(zhí)行的結果是不可預知的。

總結：1.這個方法可以在創(chuàng)建單例或者某些初始化動作時使用，以保證其唯一性。2.該方法是線程安全的，所以請放心大膽的在子線程中使用。（前提是你的dispatch_once_t *predicate對象必須是全局或者靜態(tài)對象。這一點很重要，如果不能保證這一點，也就不能保證該方法只會被執(zhí)行一次。）

轉(zhuǎn)：http://blog.sina.com.cn/s/blog_69081e0601019m1z.html

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝

大家知道，單例模式是ios里面經(jīng)常使用的模式，例如

[UIApplicationsharedApplication] (獲取當前應用程序?qū)ο?、[UIDevicecurrentDevice](獲取當前設備對象);

單例模式的寫法也很多。

第一種：

Java代碼  
static Singleton *singleton = nil;  
  
// 非線程安全,也是最簡單的實現(xiàn)  
+ (Singleton *)sharedInstance  
{  
    if (!singleton) {  
        // 這里調(diào)用alloc方法會進入下面的allocWithZone方法  
        singleton = [[self alloc] init];  
    }  
  
    return singleton;  
}  
  
  
// 這里重寫allocWithZone主要防止[[Singleton alloc] init]這種方式調(diào)用多次會返回多個對象  
+ (id)allocWithZone:(NSZone *)zone  
{  
    if (!singleton) {  
        NSLog(@"進入allocWithZone方法了...");  
        singleton = [super allocWithZone:zone];  
        return singleton;  
    }  
  
    return nil;  
}  

第二種：

Java代碼  
// 加入線程安全，防止多線程情況下創(chuàng)建多個實例  
+ (Singleton *)sharedInstance  
{  
    @synchronized(self)  
    {  
        if (!singleton) {  
            // 這里調(diào)用alloc方法會進入下面的allocWithZone方法  
            singleton = [[self alloc] init];  
        }  
    }  
  
    return singleton;  
}  
  
  
// 這里重寫allocWithZone主要防止[[Singleton alloc] init]這種方式調(diào)用多次會返回多個對象  
+ (id)allocWithZone:(NSZone *)zone  
{  
    // 加入線程安全，防止多個線程創(chuàng)建多個實例  
    @synchronized(self)  
    {  
        if (!singleton) {  
            NSLog(@"進入allocWithZone方法了...");  
            singleton = [super allocWithZone:zone];  
            return singleton;  
        }  
    }  
      
    return nil;  
}  

第三種：

Java代碼  
__strong static Singleton *singleton = nil;  
  
// 這里使用的是ARC下的單例模式  
+ (Singleton *)sharedInstance  
{  
    // dispatch_once不僅意味著代碼僅會被運行一次，而且還是線程安全的  
    static dispatch_once_t pred = 0;  
    dispatch_once(&pred, ^{  
        singleton = [[super allocWithZone:NULL] init];  
    });  
    return singleton;  
}  
// 這里  
+ (id)allocWithZone:(NSZone *)zone  
{  
      
    /* 這段代碼無法使用, 那么我們?nèi)绾谓鉀Qalloc方式呢？ 
     dispatch_once(&pred, ^{ 
        singleton = [super allocWithZone:zone]; 
        return singleton; 
    }); 
     */  
    return [self sharedInstance];  
}  
  
- (id)copyWithZone:(NSZone *)zone  
{  
    return self;  
}  

第三種是ARC下單例模式，也是比較方便的, 但是[[Singleton alloc] init];這種情況下就可以生成多個對象了，怎么辦呢，我們暫時先使用計數(shù)的方式來防止多次創(chuàng)建實例，如果大家有更好的方法，可以留言給我。謝謝~

我們采用直接返回sharedInstance的方法進行創(chuàng)建。

=======================================================

單例模式的意思就是只有一個實例。單例模式確保某一個類只有一個實例，而且自行實例化并向整個系統(tǒng)提供這個實例。這個類稱為單例類。

#import <Foundation/Foundation.h>
 
 @interface Singleton : NSObject 
 +(Singleton *) getInstance;
@end
 
 @implementation Singleton
+(Singleton *) getInstance
 { 
   static Singleton *sharedSingleton_ = nil;
   @synchronized(self){  
       if(sharedSingleton_ == nil){
          sharedSingleton_ = [NSAllocateObject([self class], 0, NULL) init];
       }
   }
   return sharedSingleton_;
 }
 
 + (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;
 }
 
 @end

當然,ios 5以上啟用ARC就簡單多了：

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

單例模式的優(yōu)缺點

1、時間和空間

比較上面兩種寫法：懶漢式是典型的時間換空間，也就是每次獲取實例都會進行判斷，看是否需要創(chuàng)建實例，浪費判斷的時間。當然，如果一直沒有人使用的話，那就不會創(chuàng)建實例，則節(jié)約內(nèi)存空間。

餓漢式是典型的空間換時間，當類裝載的時候就會創(chuàng)建類實例，不管你用不用，先創(chuàng)建出來，然后每次調(diào)用的時候，就不需要再判斷了，節(jié)省了運行時間。

2、線程安全

（1）從線程安全性上講，不加同步的懶漢式是線程不安全的，比如，有兩個線程，一個是線程A，一個是線程B，它們同時調(diào)用getInstance方法，那就可能導致并發(fā)問題。如下示例：

public static  Singleton getInstance(){  
    if(instance == null){  
 
 
 
        instance = new Singleton();  
    }  
    return instance;  
}

程序繼續(xù)運行，兩個線程都向前走了一步，如下：

public static  Singleton getInstance(){  
    if(instance == null){  
 
 
 
 
 
 
 
 
 
        instance = new Singleton();  
    }  
    return instance;  
}

可能有些朋友會覺得文字描述還是不夠直觀，再來畫個圖說明一下，如圖5.4所示。

（點擊查看大圖）圖5.4 懶漢式單例的線程問題示意圖

通過圖5.4的分解描述，明顯地看出，當A、B線程并發(fā)的情況下，會創(chuàng)建出兩個實例來，也就是單例的控制在并發(fā)情況下失效了。

（2）餓漢式是線程安全的，因為虛擬機保證只會裝載一次，在裝載類的時候是不會發(fā)生并發(fā)的。

（3）如何實現(xiàn)懶漢式的線程安全呢？

當然懶漢式也是可以實現(xiàn)線程安全的，只要加上synchronized即可，如下：

public static synchronized Singleton getInstance(){}

但是這樣一來，會降低整個訪問的速度，而且每次都要判斷。那么有沒有更好的方式來實現(xiàn)呢？

（4）雙重檢查加鎖

可以使用"雙重檢查加鎖"的方式來實現(xiàn)，就可以既實現(xiàn)線程安全，又能夠使性能不受到很大的影響。那么什么是"雙重檢查加鎖"機制呢？

所謂雙重檢查加鎖機制，指的是：并不是每次進入getInstance方法都需要同步，而是先不同步，進入方法過后，先檢查實例是否存在，如果不存在才進入下面的同步塊，這是第一重檢查。進入同步塊過后，再次檢查實例是否存在，如果不存在，就在同步的情況下創(chuàng)建一個實例，這是第二重檢查。這樣一來，就只需要同步一次了，從而減少了多次在同步情況下進行判斷所浪費的時間。

雙重檢查加鎖機制的實現(xiàn)會使用一個關鍵字volatile，它的意思是：被volatile修飾的變量的值，將不會被本地線程緩存，所有對該變量的讀寫都是直接操作共享內(nèi)存,從而確保多個線程能正確的處理該變量。

看看代碼可能會更加清楚些。示例代碼如下：

public class Singleton {  
    /**  
     * 對保存實例的變量添加volatile的修飾  
     */  
    private volatile static Singleton instance = null;  
    private Singleton(){  
    }  
    public static  Singleton getInstance(){  
        //先檢查實例是否存在，如果不存在才進入下面的同步塊  
        if(instance == null){  
            //同步塊，線程安全地創(chuàng)建實例  
            synchronized(Singleton.class){  
                //再次檢查實例是否存在，如果不存在才真正地創(chuàng)建實例  
                if(instance == null){  
                    instance = new Singleton();  
                }  
            }  
        }  
        return instance;  
    }  
}

這種實現(xiàn)方式可以實現(xiàn)既線程安全地創(chuàng)建實例，而又不會對性能造成太大的影響。它只是在第一次創(chuàng)建實例的時候同步，以后就不需要同步了，從而加快了運行速度。

================================================================

轉(zhuǎn)自： http://2015./blog/1122130

C代碼  
@implementation AppShareDataManager  
  
static AppShareDataManager * shareDataManager = nil;  
  
@synthesize theCurrentLanguage;  
@synthesize presentModalFlag;  
..........  
  
+(AppShareDataManager *) sharedManager  
{  
    if( shareDataManager == nil )  
    {  
        shareDataManager = [ [ AppShareDataManager alloc ] init ];  
    }  
    return shareDataManager;  
}  
  
-(id)init{  
    self = [super init];  
      
    if(self){  
        //對象實例初始化  
        theCurrentLanguage = [ZONUserDefaultManager getAppDefaultLanguage];  
      ........  
    }  
      
    return self;  
}  

調(diào)試發(fā)現(xiàn)

AppShareDataManager *A = [[AppShareDataManager alloc] init];

NSLog(@"A:%@",A);

AppShareDataManager *B = [AppShareDataManager sharedManager];

NSLog(@"B:%@",B);

打印出的是

2013-02-28 23:27:25.368 ZON2012[10647:c07] A:<AppShareDataManager: 0x12638630>

2013-02-28 23:27:25.369 ZON2012[10647:c07] B:<AppShareDataManager: 0xb584b40>

不是一個內(nèi)存地址，也就是不是同一個實體!

這是apple官方的一個單例建議：

https://developer.apple.com/library/mac/#documentation/Cocoa/Conceptual/CocoaFundamentals/CocoaObjects/CocoaObjects.html#//apple_ref/doc/uid/TP40002974-CH4-SW32

大致如下：

Java代碼  
/* Singleton.h */  
#import <Foundation/Foundation.h>  
  
@interface Singleton : NSObject  
+ (Singleton *)instance;  
@end  
  
/* Singleton.m */  
#import "Singleton.h"  
static Singleton *instance = nil;  
  
@implementation Singleton  
  
+ (Singleton *)instance {  
    if (!instance) {  
        instance = [[super allocWithZone:NULL] init];  
    }  
    return instance;  
}  
  
+ (id)allocWithZone:(NSZone *)zone {  
    return [self instance];  
}  
  
- (id)copyWithZone:(NSZone *)zone {  
    return self;  
}  
  
- (id)init {  
    if (instance) {  
        return instance;  
    }  
    self = [super init];  
    return self;  
}  
  
- (id)retain {  
    return self;  
}  
  
- (oneway void)release {  
    // Do nothing  
}  
  
- (id)autorelease {  
    return self;  
}  
  
- (NSUInteger)retainCount {  
    return NSUIntegerMax;  
}  
  
@end  

這是一種很標準的Singleton實現(xiàn)，中規(guī)中矩。不過這種實現(xiàn)并不是線程安全的。所以各路大神都各顯神威，給出了多種單例模式的實現(xiàn)。

現(xiàn)在把他加強下：

Java代碼  
static MyClass *class = nil;  
  
@implementation MyClass  
  
+(MyClass *)sharedMyClass{  
    @synchronized(self){  //為了確保多線程情況下，仍然確保實體的唯一性  
        if (!class) {  
            [[self alloc] init]; //該方法會調(diào)用 allocWithZone  
        }  
    }  
    return class;  
}  
+(id)allocWithZone:(NSZone *)zone{  
    @synchronized(self){// //為了確保多線程情況下，仍然確保實體的唯一性  
        if (!class) {  
            class = [super allocWithZone:zone]; //確保使用同一塊內(nèi)存地址  
            return class;  
        }  
    }  
    return nil;  
}  
  
-(id)init  
{  
  if(class){  
     return class;  
  }  
  if(self = [super init]){  
   //進行一些初始化  
   }  
   return self ;  
}   
- (id)copyWithZone:(NSZone *)zone;{  
    return self; //確保copy對象也是唯一  
}  
  
-(id)retain{  
    return self; //確保計數(shù)唯一  
}  
  
- (unsigned)retainCount  
{  
   return UINT_MAX;  //裝逼用的，這樣打印出來的計數(shù)永遠為-1  
}  
  
- (id)autorelease  
{  
    return self;//確保計數(shù)唯一  
}   
  
- (oneway void)release  
{  
     //重寫計數(shù)釋放方法 do nothing  
}  
@end  

再調(diào)試

MyClass *A = [[MyClass alloc] init];

NSLog(@"A:%@",A);

MyClass *B = [MyClass sharedMyClass];

NSLog(@"B:%@",B);

MyClass *C = [A copy];

NSLog(@"C:%@",C);

打印出的是

A:<MyClass: 0x6a1e130>

B:<MyClass: 0x6a1e130>

C:<MyClass: 0x6a1e130>

都是指向同一塊內(nèi)存地址

-----------------------------------切糕分割線--------------------------------------------------------

然而這個人（http:///blog/?p=178）覺的繁瑣，所以給出如下實現(xiàn)：

Java代碼  
@interface SomeManager : NSObject  
+ (id)sharedManager;  
@end  
  
/* 非線程安全的實現(xiàn) */  
@implementation SomeManager  
  
+ (id)sharedManager {  
    static id sharedManager = nil;  
  
    if (sharedManager == nil) {  
        sharedManager = [[self alloc] init];  
    }  
  
    return sharedManager;  
}  
@end  
  
/* 線程安全的實現(xiàn) */  
@implementation SomeManager  
  
static id sharedManager = nil;  
  
+ (void)initialize {  
    if (self == [SomeManager class]) {  
        sharedManager = [[self alloc] init];  
    }  
}  
  
+ (id)sharedManager {  
    return sharedManager;  
}  
@end  

-----------------------------------切糕分割線--------------------------------------------------------

自蘋果引入了Grand Central Dispatch (GCD)（Mac OS 10.6和iOS4.0）后，利用GCD（Grand Central Dispatch）和ARC（Automatic Reference Counting）實現(xiàn)單例。

Java代碼  
+(SchoolManager *)sharedInstance  
{  
    __strong static SchoolManager *sharedManager;  
      
    static dispatch_once_t onceToken;  
    dispatch_once(&onceToken, ^{  
        sharedManager = [[SchoolManager alloc] init];  
    });  
      
    return sharedManager;  
}  

函數(shù)void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);其中第一個參數(shù)predicate，該參數(shù)是檢查后面第二個參數(shù)所代表的代碼塊是否被調(diào)用的謂詞，第二個參數(shù)則是在整個應用程序中只會被調(diào)用一次的代碼塊。dispach_once函數(shù)中的代碼塊只會被執(zhí)行一次，而且還是線程安全的。

看到如下一篇文章，用宏實現(xiàn)（https://gist.github.com/lukeredpath/1057420）：

ExampleClass.m

@implementation MySharedThing

+ (id)sharedInstance

{

DEFINE_SHARED_INSTANCE_USING_BLOCK(^{

return [[self alloc] init];

});

}

@end

GCDSingleton.h

#define DEFINE_SHARED_INSTANCE_USING_BLOCK(block) \