【iOS】Objective-C简约而不简单的单例模式

http://leyteris.iteye.com/blog/1669198

前些日子在项目中因为误用了单例而导致了一系列问题。原来在objective-c中的单例并没有java或者C#那么简单的实现，这里记录下；

 

问题是这样被发现的，在对于一个UIViewController进行pop时并没有被dealloc，导致了内存泄露。问题代码类似于下面的：

 

C代码  

1. //LWChatViewController.h  
2. @interface LWChatViewController : LWTableViewController <LWObjSelectViewDelegate>{  
3.     UINavigationController *root;  
4. }  
5. @property (nonatomic, retain) UINavigationController *root;  
6. @end  
7.   
8. //LWChatViewController.m  
9. - (void)viewDidLoad  
10. {  
11.     [super viewDidLoad];  
12.     // Do any additional setup after loading the view from its nib.  
13.     self.root = LWNavigationController;  
14. }  

 

  这里的LWNavigationController是一个顶级的单例。

问题就出在@property (nonatomic, retain) 这里root居然是一个retain的对象指针,在这里retain一个static的单例将导致内存泄露，MD，这个bug找的我好久。。。

 

 

解决这个问题其实很简单，把retain改为assign就行了，但这样如果在协作编程的时候如果别人不在意这个是单例直接进行常规操作的话会带来很大的问题。

 

 

继续，我们来从根本上解决这个问题。

我们需要重写一些方法：

 

C代码  

1. - (id)retain  
2. {  
3.     return self;  
4. }  
5.   
6. - (NSUInteger) retainCount  
7. {  
8.     return NSUIntegerMax;  
9. }  
10.   
11. - (void) release  
12. {  
13.     // do nothing  
14. }  
15.   
16. - (id)autorelease  
17. {  
18.     return self;  
19. }  

在retain和autorelease什么都不做只是返回自己，release的时候啥都不做，将retainCount设为UInt的极大值。

 

其次是关于线程安全的实现，这些java都有明确的代码模式：

关于线程安全的单例，这篇外文 http://www.numbergrinder.com/2008/12/patterns-in-objective-c-singleton-pattern/ 有比较详细的解释。

 

 

Java代码  

1. @implementation Singleton  
2. static Singleton *instance = nil;  
3. + (Singleton *)sharedInstance  {  
4.    @synchronized(self)   
5.    {  
6.         if(!instance) {  
7.            instance = [[super allocWithZone:NULL] init];  
8.         }  
9.     }  
10.    
11.     return instance;  
12. }  
13.    
14. @end  

 

嗯，这样就可以实现线程安全的单例了，当然这里也可以用NSLock实例去实现。

 

本类的allocWithZone被改写为：

 

C代码  

1. + (id)allocWithZone:(NSZone *)zone  
2. {  
3.       return [self sharedInstance];  
4. }  
5.   
6. - (id)copyWithZone:(NSZone *)zone  
7. {  
8.       return self;  
9. }  

 同时深拷贝也直接重载阻止掉多个实例的出现。上面的allocWithZone的重载使得这个单例也能够直接用alloc或是allocWithZone进行初始化，但返回的一如既往是那个static的实例。

dispatch_once为什么能做到既解决同步多线程问题又不影响性能呢？
下面我们来看看dispatch_once的原理：

dispatch_once主要是根据onceToken的值来决定怎么去执行代码。

1. 当onceToken = 0时，线程执行dispatch_once的block中代码
2. 当onceToken = -1时，线程跳过dispatch_once的block中代码不执行
3. 当onceToken为其他值时，线程被线程被阻塞，等待onceToken值改变

当线程首先调用shareInstance，某一线程要执行block中的代码时，首先需要改变onceToken的值，再去执行block中的代码。这里onceToken的值变为了140734731430192。
这样当其他线程再获取onceToken的值时，值已经变为140734731430192。其他线程被阻塞。
当block线程执行完block之后。onceToken变为-1。其他线程不再阻塞，跳过block。
下次再调用shareInstance时，block已经为-1。直接跳过block。
这样dispatch_once在首次调用时同步阻塞线程，生成单例之后，不再阻塞线程。dispatch_once是创建单例的最优方案