IOS single case (Singleton) Summary and third Library Reference Singleton

Reference: HTTP://BLOG.CSDN.NET/LOVEFQING/ARTICLE/DETAILS/8516536#T3

http://blog.csdn.net/kindazrael/article/details/7917863

The singleton pattern is used when a class can have only one instance, typically this "singleton " represents a physical device such as a printer, or some kind of virtual resource or system attribute, such as a program's engine or data, that can not have multiple instances at the same time. The simplest example is that when the user opens the QQ space to play music, here is a singleton, if not a single case, click on other pages QQ music will automatically start from the beginning. It is necessary to control it with a single-case pattern.

What the singleton model needs to achieve

1. encapsulating a shared resource

2. provide a fixed instance creation method

3. provide a standard instance access interface

Creating a singleton pattern

This article takes the example of creating a Mysingletonclass singleton pattern. First, we need to define a class of Mysingletonclass.

[CPP]View Plaincopy

1. @interface Mysingletonclass:nsobject {
3. }

and add a class method for it (note that this is not an instance method)+ (ID) sharedinstance; a basic implementation is as follows:

static Mysingletonclass *sharedinstance = nil;

1. + (mysingletonclass *) sharedinstance{  
2.      @synchronized (self)  {  
3.          if (sharedinstance == nil)  {  
4.            sharedinstance = [[Mysingletonclass alloc]init];
5.         }  
6.      }  
7.     return sharedinstance;  
8. }  

In the above code (the keyword @synchronized is used to ensure that our singleton thread-level security can be applied in multithreaded mode. Thestatic variable sharedcldelegate is used to store a pointer to a singleton, and forcing all access to the variable must pass the class method + (ID) sharedinstance, on the + ( ID) Sharedinstance the creation of the instance the first time it is called. It is worth noting that the code above is [[Self class] alloc] instead of [Mysingletonclass alloc], which generally produces the same effect.

Control of the instantiation

In order to fully realize the uniqueness of the instance, it is necessary to avoid the instance being created multiple times by certain means. + (ID) sharedinstance controls the creation and access of the singleton, but does not control the code elsewhere to create more instances through the Alloc method, so we also overload any method that involves allocation, These methods include +new, +alloc,+allocwithzone:,-copywithzone:, and-mutablecopywithzone: Plus, + (ID) sharedinstance A minor modification is also required.

2. + (ID) hiddenalloc
4. {
6. return [Super alloc];
8. }
14. + (ID) alloc
16. {
18. NSLog (@'%@: Use +sharedinstance instead of +alloc ', [[Self class] name];
20. return nil;
22. }
28. + (ID)new
30. {
32. return [self alloc];
34. }
38. + (ID) Allocwithzone: (nszone*) zone
40. {
42. return [self alloc];
44. }
48. -(ID) Copywithzone: (Nszone *) zone
50. { //-copy inherited from NSObject Calls-copywithzone:
52. NSLog (@"Mysingletonclass:attempt to-copy may be a bug.");
54. [Self retain];
56. return self;
58. }
62. -(ID) Mutablecopywithzone: (Nszone *) zone
64. {
66. //-mutablecopy inherited from NSObject Calls-mutablecopywithzone:
68. return [self copywithzone:zone];
70. }
74. + (ID) sharedinstance modified as follows:
78. + (Mysingletonclass *) sharedinstance {
80. @synchronized (self) {
82. if (sharedcldelegate = = nil) {
84. [[Self class] hiddenalloc] init]; //Assignment not do here
86. }
88. }
90. return sharedcldelegate;
92. }

If the subclass of the class is not considered,the +hiddenalloc method can be omitted. Since we are using [Self class] to implement dynamic recognition of the type, using [[Selfclass] hiddenalloc] can avoid calling to the overloaded Alloc method. In addition,Hiddenalloc provides an opportunity to invoke the original Alloc method for possible subclasses . The overloaded Alloc method above simply gives a log message and returns nil. The copying method simply increases the count of retain and does not return a new instance. This is also a manifestation of the nature of the singleton pattern, because technically, copying a single case is wrong (because it is a "singleton ") so in the Copywithzone method we give an error message, and of course we can throw a exception.

Single-Instance Destruction

usually we call the following method in the-(void) Applicationwillterminate: (uiapplication *) Application method:

1. + (void) Attemptdealloc
2. {
3. if ([sharedcldelegate retaincount]! = 1)
4. return;
6. [Sharedcldelegate release];
7. MyInstance = nil;
8. }

It is worth noting that the above Attemptdealloc method, as its name implies, is simply trying to release the Singleton. If the count of retain is not 1, there are other places where retain messages have been sent to the single case . Consider that the lifetime of a singleton pattern is the end of the entire program. Therefore, there is no need to send a retain message to this single case anywhere in the program , even if the singleton is referenced. Instead of invoking the Sharedinstance method to refer to this singleton, it is safe to do so and is consistent with the technical implications of the Singleton pattern.

Here you need to set a parameter to manage memory manually.

the singleton mode app in iOS

There are several classes in IOS that use singleton patterns, such as NSApplication, Nsfontmanager, Nsdocumentcontroller,nshelpmanager, NSNull, Nsprocessinfo, Nsscriptexecutioncontext, nsuserdefaults.

2. Official advice
6. Since there is a certain risk in designing a single mode, the main consideration is the problem that may occur in multi-threaded situations, so Apple recommends using the following methods to achieve a single mode:
8. static Mygizmoclass *sharedgizmomanager = nil;
10. + (mygizmoclass*) Sharedmanager
12. {
14. @synchronized (self) {
16. if (Sharedgizmomanager = = nil) {
18. [[Self alloc] init]; Assignment not do here
20. }
22. }
24. return sharedgizmomanager;
26. }
28. + (ID) Allocwithzone: (Nszone *) zone
30. {
32. @synchronized (self) {
34. if (Sharedgizmomanager = = nil) {
36. Sharedgizmomanager = [Super Allocwithzone:zone];
38. return sharedgizmomanager; Assignment and return on first allocation
40. }
42. }
44. return nil; On subsequent allocation attempts return nil
46. }
48. -(ID) Copywithzone: (Nszone *) zone
50. {
52. return self;
54. }
56. -(ID) retain
58. {
60. return self;
62. }
64. -(unsigned) retaincount
66. {
68. return Uint_max; Denotes an object, cannot be released
70. }
72. -(void) Release
74. {
76. Do nothing
78. }
80. -(ID) autorelease
82. {
84. return self;
86. }
90. Since the singleton mode basically conforms to the above design, when there are many classes to be designed into a singleton pattern, you can define
92. A single template macro to improve the reuse of programs and reduce unnecessary errors.
94. #define SYNTHESIZE_SINGLETON_FOR_CLASS (classname) \
96. \
98. static classname *shared# #classname = nil; \
100. \
102. + (classname *) shared# #classname \
104. { \
106. @synchronized (self) \
108. { \
110. if (shared# #classname = = nil) \
112. { \
114. shared# #classname = [[Self alloc] init]; \
116. } \
118. } \
120. \
122. return shared# #classname; \
124. } \
126. \
128. + (ID) Allocwithzone: (nszone *) zone \
130. { \
132. @synchronized (self) \
134. { \
136. if (shared# #classname = = nil) \
138. { \
140. shared# #classname = [Super Allocwithzone:zone]; \
142. return shared# #classname; \
144. } \
146. } \
148. \
150. Returnnil; \
152. } \
154. \
156. -(ID) Copywithzone: (nszone *) zone \
158. { \
160. returnself; \
162. } \
164. \
166. -(ID) retain \
168. { \
170. returnself; \
172. } \
174. \
176. -(Nsuinteger) retaincount \
178. { \
180. return Nsuintegermax; \
182. } \
184. \
186. -(void) release \
188. { \
190. } \
192. \
194. -(ID) autorelease \
196. { \
198. returnself; \
200. }

Usage: Suppose the Apppreference class is to implement a single case

#import "AppPreference.h"

#import "SingletonTemplate.h"

@implementation Apppreference

Use the macro template to generate the code required for the singleton

Synthesize_singleton_for_class (apppreference)

This is a test method

+ (void) Test {

Use a single case

Apppreference *apppreference = [Apppreference sharedapppreference];

}

@end

IOS single case (Singleton) Summary and third Library Reference Singleton