您的位置: 首页  >  IT文章  >  iOS设计模式之单例模式 第一种方法： 第二种方法：dispatch_once：

iOS设计模式之单例模式 第一种方法： 第二种方法：dispatch_once：

分类: IT文章 • 2022-08-11 00:17:42

 

单例模式是iOS常用设计模式中的一种。单例设计模式的作用是使得这个类的一个对 象成为系统中的唯一实例，因此需要用一种唯一的方法去创建这个对象并返回这个对象的地址。那么，我们何时使用单例模式呢？

1、类只能有一个实例，而且必须从一个为人熟知的访问点对其访问。

2、这个唯一的实例只能通过子类化进行扩展，而且扩展的对象不会破坏客户端代码。

 那么用Objective-C如何实现单例模式呢？

下面我们来新建一个Singleton类，在Singleton.h中实现如下

@interface Singleton : NSObject
	+ (Singleton *) sharedInstance;
@end



在Singleton.m

 @implementation Singleton
	static Singleton * sharedSingleton = nil;
+ (Singleton *) sharedInstance {
	if (sharedSingleton == nil) {
	sharedSingleton = [[Singleton alloc] init];
	}
	return sharedSingleton;
}
 @end





这样就创建一个简单的单例模式，实际上有一部分程序员也是这样实现的，但实际上这是一个不“严格”版本，在实际中使用，可能 会遇到发起调用的对象不能以其他分配方式实例化单例对象，否则，就会创建多个实例。（之前有人和我讨论过这个问题，说使用者应该严格按照接口来使用，当实 际上Singleton是一个对象，我们不能保证使用者不会使用其他的方法去创建（比如alloc）,这个时候他就会创建多个实例，这样就会出现这些无法 感知的bug）

　在objective-c中要实现一个单例类，至少需要做以下四个步骤：

　　1、为单例对象实现一个静态实例，并初始化，然后设置成nil，
　　2、实现一个实例构造方法检查上面声明的静态实例是否为nil，如果是则新建并返回一个本类的实例，
　　3、重写allocWithZone方法，用来保证其他人直接使用alloc和init试图获得一个新实力的时候不产生一个新实例，
　　4、适当实现allocWitheZone，copyWithZone，release和autorelease。
下面以完善上述例子：
static Singleton *sharedSingleton = nil; //第一步：静态实例，并初始化。
@implementation Singleton
+ (Singleton*) sharedInstance //第二步：实例构造检查静态实例是否为nil
{
 @synchronized (self) {
if (sharedSingleton == nil) {
 [[self alloc] init];
}
}
 return sharedSingleton;
}

+ (id) allocWithZone:(NSZone *)zone //第三步：重写allocWithZone方法
{
@synchronized (self) {
	 if (sharedSingleton == nil) {
	sharedObj = [super allocWithZone:zone];
	return sharedSingleton;
		}
	}
 return nil;
}

 - (id) copyWithZone:(NSZone *)zone //第四步
 {
	 return self;
}

- (id) retain
{
	 return self;
}

 - (unsigned) retainCount
 {
	return UINT_MAX;
}

- (oneway void) release {
 }
- (id) autorelease
{
	return self;
 }
- (id)init {
@synchronized(self)
	 {
	[super init];//往往放一些要初始化的变量.
	 return self;
	}
}
@end





也许你注意到了，我重载了allocWithZone: 保持了从sharedInstance方法返回的单例对象，使用者哪怕使用 alloc时也会返回唯一的实例（alloc方法中会先调用allocWithZone:创建对象）。而retain等内存管理的函数也被重载了，这样做 让我们有了把Singleton类变得“严格”了。

第二种方法：dispatch_once：

void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);


该函数接收一个dispatch_once用于检查该代码块是否已经被调度的谓词（是一个长整型，实际上作为BOOL使用）。它还接收一个希望在应用的生命周期内仅被调度一次的代码块，对于本例就用于shared实例的实例化。
dispatch_once不仅意味着代码仅会被运行一次，而且还是线程安全的，这就意味着你不需要使用诸如@synchronized之类的来防止使用多个线程或者队列时不同步的问题。
 
实际要如何使用这些呢?
 
好吧，假设有一个AccountManager类，你想在整个应用中访问该类的共享实例。你可以按如下代码简单实现一个类方法：
+ (AccountManager *)sharedManager
{
static AccountManager *sharedAccountManagerInstance = nil;
static dispatch_once_t predicate;
dispatch_once(&predicate, ^{ sharedAccountManagerInstance = [[self alloc] init]; });
 return sharedAccountManagerInstance;
}





    这就意味着你任何时候访问共享实例，需要做的仅是：
AccountManager *accountManager = [AccountManager sharedManager];
    就这些，你现在在应用中就有一个共享的实例，该实例只会被创建一次。
    该方法有很多优势:
           1 线程安全
           2 很好满足静态分析器要求
           3 和自动引用计数（ARC）兼容
           4 仅需要少量代码
    该方法的劣势就是它仍然运行创建一个非共享的实例：
AccountManager *accountManager = [[AccountManager alloc] init];


 有些时候你希望有这种行为，但如果正在想要的是仅一个实例被实例化就需要注意这点。

 

单例模式是iOS常用设计模式中的一种。单例设计模式的作用是使得这个类的一个对 象成为系统中的唯一实例，因此需要用一种唯一的方法去创建这个对象并返回这个对象的地址。那么，我们何时使用单例模式呢？

1、类只能有一个实例，而且必须从一个为人熟知的访问点对其访问。

2、这个唯一的实例只能通过子类化进行扩展，而且扩展的对象不会破坏客户端代码。

 那么用Objective-C如何实现单例模式呢？

下面我们来新建一个Singleton类，在Singleton.h中实现如下

@interface Singleton : NSObject
	+ (Singleton *) sharedInstance;
@end



在Singleton.m

 @implementation Singleton
	static Singleton * sharedSingleton = nil;
+ (Singleton *) sharedInstance {
	if (sharedSingleton == nil) {
	sharedSingleton = [[Singleton alloc] init];
	}
	return sharedSingleton;
}
 @end





这样就创建一个简单的单例模式，实际上有一部分程序员也是这样实现的，但实际上这是一个不“严格”版本，在实际中使用，可能 会遇到发起调用的对象不能以其他分配方式实例化单例对象，否则，就会创建多个实例。（之前有人和我讨论过这个问题，说使用者应该严格按照接口来使用，当实 际上Singleton是一个对象，我们不能保证使用者不会使用其他的方法去创建（比如alloc）,这个时候他就会创建多个实例，这样就会出现这些无法 感知的bug）

　在objective-c中要实现一个单例类，至少需要做以下四个步骤：

　　1、为单例对象实现一个静态实例，并初始化，然后设置成nil，
　　2、实现一个实例构造方法检查上面声明的静态实例是否为nil，如果是则新建并返回一个本类的实例，
　　3、重写allocWithZone方法，用来保证其他人直接使用alloc和init试图获得一个新实力的时候不产生一个新实例，
　　4、适当实现allocWitheZone，copyWithZone，release和autorelease。
下面以完善上述例子：
static Singleton *sharedSingleton = nil; //第一步：静态实例，并初始化。
@implementation Singleton
+ (Singleton*) sharedInstance //第二步：实例构造检查静态实例是否为nil
{
 @synchronized (self) {
if (sharedSingleton == nil) {
 [[self alloc] init];
}
}
 return sharedSingleton;
}

+ (id) allocWithZone:(NSZone *)zone //第三步：重写allocWithZone方法
{
@synchronized (self) {
	 if (sharedSingleton == nil) {
	sharedObj = [super allocWithZone:zone];
	return sharedSingleton;
		}
	}
 return nil;
}

 - (id) copyWithZone:(NSZone *)zone //第四步
 {
	 return self;
}

- (id) retain
{
	 return self;
}

 - (unsigned) retainCount
 {
	return UINT_MAX;
}

- (oneway void) release {
 }
- (id) autorelease
{
	return self;
 }
- (id)init {
@synchronized(self)
	 {
	[super init];//往往放一些要初始化的变量.
	 return self;
	}
}
@end





也许你注意到了，我重载了allocWithZone: 保持了从sharedInstance方法返回的单例对象，使用者哪怕使用 alloc时也会返回唯一的实例（alloc方法中会先调用allocWithZone:创建对象）。而retain等内存管理的函数也被重载了，这样做 让我们有了把Singleton类变得“严格”了。

第二种方法：dispatch_once：

void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);


该函数接收一个dispatch_once用于检查该代码块是否已经被调度的谓词（是一个长整型，实际上作为BOOL使用）。它还接收一个希望在应用的生命周期内仅被调度一次的代码块，对于本例就用于shared实例的实例化。
dispatch_once不仅意味着代码仅会被运行一次，而且还是线程安全的，这就意味着你不需要使用诸如@synchronized之类的来防止使用多个线程或者队列时不同步的问题。
 
实际要如何使用这些呢?
 
好吧，假设有一个AccountManager类，你想在整个应用中访问该类的共享实例。你可以按如下代码简单实现一个类方法：
+ (AccountManager *)sharedManager
{
static AccountManager *sharedAccountManagerInstance = nil;
static dispatch_once_t predicate;
dispatch_once(&predicate, ^{ sharedAccountManagerInstance = [[self alloc] init]; });
 return sharedAccountManagerInstance;
}





    这就意味着你任何时候访问共享实例，需要做的仅是：
AccountManager *accountManager = [AccountManager sharedManager];
    就这些，你现在在应用中就有一个共享的实例，该实例只会被创建一次。
    该方法有很多优势:
           1 线程安全
           2 很好满足静态分析器要求
           3 和自动引用计数（ARC）兼容
           4 仅需要少量代码
    该方法的劣势就是它仍然运行创建一个非共享的实例：
AccountManager *accountManager = [[AccountManager alloc] init];


 有些时候你希望有这种行为，但如果正在想要的是仅一个实例被实例化就需要注意这点。

 

@interface Singleton : NSObject
	+ (Singleton *) sharedInstance;
@end


@interface Singleton : NSObject
	+ (Singleton *) sharedInstance;
@end


 @implementation Singleton
	static Singleton * sharedSingleton = nil;
+ (Singleton *) sharedInstance {
	if (sharedSingleton == nil) {
	sharedSingleton = [[Singleton alloc] init];
	}
	return sharedSingleton;
}
 @end



 
 @implementation Singleton
	static Singleton * sharedSingleton = nil;
+ (Singleton *) sharedInstance {
	if (sharedSingleton == nil) {
	sharedSingleton = [[Singleton alloc] init];
	}
	return sharedSingleton;
}
 @end


static Singleton *sharedSingleton = nil; //第一步：静态实例，并初始化。
@implementation Singleton
+ (Singleton*) sharedInstance //第二步：实例构造检查静态实例是否为nil
{
 @synchronized (self) {
if (sharedSingleton == nil) {
 [[self alloc] init];
}
}
 return sharedSingleton;
}

+ (id) allocWithZone:(NSZone *)zone //第三步：重写allocWithZone方法
{
@synchronized (self) {
	 if (sharedSingleton == nil) {
	sharedObj = [super allocWithZone:zone];
	return sharedSingleton;
		}
	}
 return nil;
}

 - (id) copyWithZone:(NSZone *)zone //第四步
 {
	 return self;
}

- (id) retain
{
	 return self;
}

 - (unsigned) retainCount
 {
	return UINT_MAX;
}

- (oneway void) release {
 }
- (id) autorelease
{
	return self;
 }
- (id)init {
@synchronized(self)
	 {
	[super init];//往往放一些要初始化的变量.
	 return self;
	}
}
@end




static Singleton *sharedSingleton = nil; //第一步：静态实例，并初始化。
@implementation Singleton
+ (Singleton*) sharedInstance //第二步：实例构造检查静态实例是否为nil
{
 @synchronized (self) {
if (sharedSingleton == nil) {
 [[self alloc] init];
}
}
 return sharedSingleton;
}

+ (id) allocWithZone:(NSZone *)zone //第三步：重写allocWithZone方法
{
@synchronized (self) {
	 if (sharedSingleton == nil) {
	sharedObj = [super allocWithZone:zone];
	return sharedSingleton;
		}
	}
 return nil;
}

 - (id) copyWithZone:(NSZone *)zone //第四步
 {
	 return self;
}

- (id) retain
{
	 return self;
}

 - (unsigned) retainCount
 {
	return UINT_MAX;
}

- (oneway void) release {
 }
- (id) autorelease
{
	return self;
 }
- (id)init {
@synchronized(self)
	 {
	[super init];//往往放一些要初始化的变量.
	 return self;
	}
}
@end




static Singleton *sharedSingleton = nil; //第一步：静态实例，并初始化。
@implementation Singleton
+ (Singleton*) sharedInstance //第二步：实例构造检查静态实例是否为nil
{
 @synchronized (self) {
if (sharedSingleton == nil) {
 [[self alloc] init];
}
}
 return sharedSingleton;
}

+ (id) allocWithZone:(NSZone *)zone //第三步：重写allocWithZone方法
{
@synchronized (self) {
	 if (sharedSingleton == nil) {
	sharedObj = [super allocWithZone:zone];
	return sharedSingleton;
		}
	}
 return nil;
}

 - (id) copyWithZone:(NSZone *)zone //第四步
 {
	 return self;
}

- (id) retain
{
	 return self;
}

 - (unsigned) retainCount
 {
	return UINT_MAX;
}

- (oneway void) release {
 }
- (id) autorelease
{
	return self;
 }
- (id)init {
@synchronized(self)
	 {
	[super init];//往往放一些要初始化的变量.
	 return self;
	}
}
@end




void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);


该函数接收一个dispatch_once用于检查该代码块是否已经被调度的谓词（是一个长整型，实际上作为BOOL使用）。它还接收一个希望在应用的生命周期内仅被调度一次的代码块，对于本例就用于shared实例的实例化。
void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);


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





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


AccountManager *accountManager = [AccountManager sharedManager];

AccountManager *accountManager = [AccountManager sharedManager];

AccountManager *accountManager = [[AccountManager alloc] init];


AccountManager *accountManager = [[AccountManager alloc] init];



相关推荐