iOS single-instance mode detailed

http://blog.csdn.net/a451493485/article/details/8624990

C code

2. @implementation Appsharedatamanager
6. Static Appsharedatamanager * Sharedatamanager = nil;
10. @synthesize Thecurrentlanguage;
12. @synthesize Presentmodalflag;
14. ..........
18. + (Appsharedatamanager *) Sharedmanager
20. {
22. if (Sharedatamanager = = nil)
24. {
26. Sharedatamanager = [[Appsharedatamanager alloc] init];
28. }
30. return Sharedatamanager;
32. }
36. -(ID) init{
38. self = [super init];
42. if (self) {
44. //Object instance initialization
46. Thecurrentlanguage = [Zonuserdefaultmanager getappdefaultlanguage];
48. ........
50. }
54. return self;
56. }

Debug discovery

Appsharedatamanager *a = [[Appsharedatamanager alloc] init];

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

Appsharedatamanager *b = [Appsharedatamanager Sharedmanager];

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

Print Out is the

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>

Not a memory address, which is not the same entity!

This is one of Apple's official single-case recommendations:

https://developer.apple.com/library/mac/#documentation/cocoa/conceptual/cocoafundamentals/cocoaobjects/ Cocoaobjects.html#//apple_ref/doc/uid/tp40002974-ch4-sw32

Roughly as follows:

Java code

2. /* Singleton.h */
4. #Import &lt;  Foundation/foundation.h&gt;
8. @interface Singleton:nsobject
10. + (Singleton *) instance;
12. @end
16. /* SINGLETON.M */
18. #Import "Singleton.h"
20. static Singleton *instance = nil;
24. @implementation Singleton
28. + (Singleton *) Instance {
30. if (!instance) {
32. instance = [[super Allocwithzone:null] init];
34. }
36. return instance;
38. }
42. + (ID) Allocwithzone: (Nszone *) Zone {
44. return [self instance];
46. }
50. -(ID) Copywithzone: (Nszone *) Zone {
52. return self;
54. }
58. -(ID) init {
60. if (instance) {
62. return instance;
64. }
66. self = [super init];
68. return self;
70. }
74. -(ID) retain {
76. return self;
78. }
82. -(oneway void) Release {
84. // do nothing
86. }
90. -(ID) autorelease {
92. return self;
94. }
98. -(Nsuinteger) Retaincount {
100. return Nsuintegermax;
102. }
106. @end

This is a very standard singleton implementation, good. However, this implementation is not thread-safe. So the great gods of each way show their divinity, and give the realization of a variety of single-case patterns.

Now put him under the step:

Java code

2. Static MyClass *class = nil;
6. @implementation MyClass
10. + (MyClass *) sharedmyclass{
12. @synchronized (self) { //To ensure the uniqueness of the entity in the case of multithreading
14. if (! Class) {
16. [[Self alloc] init]; //This method calls Allocwithzone
18. }
20. }
22. return class;
24. }
26. + (ID) Allocwithzone: (Nszone *) zone{
28. @synchronized (self) {//////To ensure the uniqueness of the entity in the case of multithreading
30. if (! Class) {
32. class = [Super Allocwithzone:zone]; //Make sure to use the same memory address
34. return class;
36. }
38. }
40. return nil;
42. }
46. -(ID) init
48. {
50. if (Class) {
52. return class;
54. }
56. if (self = [Super init]) {
58. //Perform some initialization
60. }
62. return self;
64. }
66. -(ID) Copywithzone: (Nszone *) zone; {
68. return self; //Ensure that the Copy object is also unique
70. }
74. -(ID) retain{
76. return self; //Ensure that the count is unique
78. }
82. -(unsigned) retaincount
84. {
86. return Uint_max; //loaded, so that the printed count is always-1
88. }
92. -(ID) autorelease
94. {
96. return self; //Ensure that the count is unique
98. }
102. -(oneway void) Release
104. {
106. //Override Count Release method do nothing
108. }
110. @end

Re-commissioning

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

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

MyClass *b = [MyClass sharedmyclass];

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

MyClass *c = [A copy];

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

Print Out is the

A:<myclass:0x6a1e130>

B:<myclass:0x6a1e130>

C:<myclass:0x6a1e130>

All pointing to the same block memory address

-----------------------------------cut cake Split line--------------------------------------------------------

However, this person (http://eschatologist.net/blog/?p=178) feels the tedious, so gives the following realization:

Java code

2. @interface Somemanager:nsobject
4. + (ID) Sharedmanager;
6. @end
10. /* Non-thread safe implementation */
12. @implementation Somemanager
16. + (ID) Sharedmanager {
18. static id Sharedmanager = NIL;
22. if (Sharedmanager = = nil) {
24. Sharedmanager = [[Self alloc] init];
26. }
30. return Sharedmanager;
32. }
34. @end
38. /* Thread-safe Implementation */
40. @implementation Somemanager
44. Static id Sharedmanager = NIL;
48. + (void) Initialize {
50. if (self = = [Somemanager class]) {
52. Sharedmanager = [[Self alloc] init];
54. }
56. }
60. + (ID) Sharedmanager {
62. return Sharedmanager;
64. }
66. @end

-----------------------------------cut cake split line--------------------------------------------------------

since Apple introduced Grand Central Dispatch (GCD) (Mac OS 10.6 and iOS4.0), the use of GCD (Grand Central Dispatch) and arc (Automatic Reference counting) to implement a single case.

Java code

1. + (schoolmanager *) sharedinstance  
2. {  
3.     __strong static schoolmanager *sharedmanager;   
4.       
5.     STATIC&NBSP;DISPATCH_ONCE_T&NBSP;ONCETOKEN;&NBSP;&NBSP;
6.      Dispatch_once (&oncetoken, ^{  
7.          sharedmanager = [[schoolmanager alloc] init];  
8.      });   
9.       
10.      RETURN&NBSP;SHAREDMANAGER;&NBSP;&NBSP;
11. }  

function void Dispatch_once (dispatch_once_t *predicate, dispatch_block_t block), where the first parameter predicate, This parameter is a predicate that checks whether the block of code represented by the second argument is called, and the second parameter is a block of code that will only be called once throughout the application. The code blocks in the Dispach_once function are only executed once and are thread-safe.

See the following article, with a macro implementation (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) \static dispatch_once_t pred = 0; \__strong static id _sharedobject = NIL; \dispatch_once (&pred, ^{\_sharedobject = block (); \}); \return _sharedobject; \

iOS single-instance mode detailed