创建一个单例很多办法。我先列举一个苹果官方文档中的写法。
[cpp]
view plaincopystatic AccountManager *DefaultManager = nil;
+ (AccountManager *)defaultManager {
if (!DefaultManager) DefaultManager = [[self allocWithZone:NULL] init];
return DefaultManager;
}
当然，在iOS4之后有了另外一种写法：
[cpp]
view plaincopy+ (AccountManager *)sharedManager
{
static AccountManager *sharedAccountManagerInstance = nil;
static dispatch_once_t predicate;
dispatch_once(&predicate, ^{
sharedAccountManagerInstance = [[self alloc] init];
});
return sharedAccountManagerInstance;
}
该写法来自
objcolumnist，文中提到，该写法具有以下几个特性：
1. 线程安全。
2. 满足静态分析器的要求。
3. 兼容了ARC
然后我还有点好奇的是dispatch_once,这个函数，没见过啊。
于是就到官方的文档里找找看，是怎么说的。
下面是官方文档介绍：
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
我们看到，该方法的作用就是执行且在整个程序的声明周期中，仅执行一次某一个block对象。简直就是为单例而生的嘛。而且，有些我们需要在程序开头初始化的动作，如果为了保证其，仅执行一次，也可以放到这个dispatch_once来执行。
然后我们看到它需要一个断言来确定这个代码块是否执行，这个断言的指针要保存起来，相对于第一种方法而言，还需要多保存一个指针。
方法简介中就说的很清楚了：对于在应用中创建一个初始化一个全局的数据对象（单例模式），这个函数很有用。
如果同时在多线程中调用它，这个函数将等待同步等待，直至该block调用结束。
这个断言的指针必须要全局化的保存，或者放在静态区内。使用存放在自动分配区域或者动态区域的断言，dispatch_once执行的结果是不可预知的。
总结：1.这个方法可以在创建单例或者某些初始化动作时使用，以保证其唯一性。2.该方法是线程安全的，所以请放心大胆的在子线程中使用。（前提是你的dispatch_once_t *predicate对象必须是全局或者静态对象。这一点很重要，如果不能保证这一点，也就不能保证该方法只会被执行一次。）
转：
http://blog.sina.com.cn/s/blog_69081e0601019m1z.html＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
大家知道，单例模式是ios里面经常使用的模式，例如
[UIApplicationsharedApplication] (获取当前应用程序对象)、[UIDevicecurrentDevice](获取当前设备对象);
单例模式的写法也很多。
第一种：
Java代码
static Singleton *singleton = nil;
// 非线程安全,也是最简单的实现
+ (Singleton *)sharedInstance
{
if (!singleton) {
// 这里调用alloc方法会进入下面的allocWithZone方法
singleton = [[self alloc] init];
}
return singleton;
}
// 这里重写allocWithZone主要防止[[Singleton alloc] init]这种方式调用多次会返回多个对象
+ (id)allocWithZone:(NSZone *)zone
{
if (!singleton) {
NSLog(@"进入allocWithZone方法了...");
singleton = [super allocWithZone:zone];
return singleton;
}
return nil;
}
第二种：
Java代码
// 加入线程安全，防止多线程情况下创建多个实例
+ (Singleton *)sharedInstance
{
@synchronized(self)
{
if (!singleton) {
// 这里调用alloc方法会进入下面的allocWithZone方法
singleton = [[self alloc] init];
}
}
return singleton;
}
// 这里重写allocWithZone主要防止[[Singleton alloc] init]这种方式调用多次会返回多个对象
+ (id)allocWithZone:(NSZone *)zone
{
// 加入线程安全，防止多个线程创建多个实例
@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
{
/* 这段代码无法使用, 那么我们如何解决alloc方式呢？
dispatch_once(&pred, ^{
singleton = [super allocWithZone:zone];
return singleton;
});
*/
return [self sharedInstance];
}
- (id)copyWithZone:(NSZone *)zone
{
return self;
}
第三种是ARC下单例模式，也是比较方便的, 但是[[Singleton alloc] init];这种情况下就可以生成多个对象了，怎么办呢，我们暂时先使用计数的方式来防止多次创建实例，如果大家有更好的方法，可以留言给我。谢谢~
我们采用直接返回sharedInstance的方法进行创建。
=======================================================
单例模式的意思就是只有一个实例。单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。
#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;}
单例模式的优缺点
1、时间和空间
比较上面两种写法：懒汉式是典型的时间换空间，也就是每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。当然，如果一直没有人使用的话，那就不会创建实例，则节约内存空间。
饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。
2、线程安全
（1）从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题。如下示例：
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
程序继续运行，两个线程都向前走了一步，如下：
public static Singleton getInstance(){
if(instance == null){
instance = new Singleton();
}
return instance;
}
可能有些朋友会觉得文字描述还是不够直观，再来画个图说明一下，如图5.4所示。
（点击查看大图）图5.4 懒汉式单例的线程问题示意图
通过图5.4的分解描述，明显地看出，当A、B线程并发的情况下，会创建出两个实例来，也就是单例的控制在并发情况下失效了。
（2）饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。
（3）如何实现懒汉式的线程安全呢？
当然懒汉式也是可以实现线程安全的，只要加上synchronized即可，如下：
public static synchronized Singleton getInstance(){}
但是这样一来，会降低整个访问的速度，而且每次都要判断。那么有没有更好的方式来实现呢？
（4）双重检查加锁
可以使用"双重检查加锁"的方式来实现，就可以既实现线程安全，又能够使性能不受到很大的影响。那么什么是"双重检查加锁"机制呢？
所谓双重检查加锁机制，指的是：并不是每次进入getInstance方法都需要同步，而是先不同步，进入方法过后，先检查实例是否存在，如果不存在才进入下面的同步块，这是第一重检查。进入同步块过后，再次检查实例是否存在，如果不存在，就在同步的情况下创建一个实例，这是第二重检查。这样一来，就只需要同步一次了，从而减少了多次在同步情况下进行判断所浪费的时间。
双重检查加锁机制的实现会使用一个关键字volatile，它的意思是：被volatile修饰的变量的值，将不会被本地线程缓存，所有对该变量的读写都是直接操作共享内存,从而确保多个线程能正确的处理该变量。
看看代码可能会更加清楚些。示例代码如下：
public class Singleton {
/**
* 对保存实例的变量添加volatile的修饰
*/
private volatile static Singleton instance = null;
private Singleton(){
}
public static Singleton getInstance(){
//先检查实例是否存在，如果不存在才进入下面的同步块
if(instance == null){
//同步块，线程安全地创建实例
synchronized(Singleton.class){
//再次检查实例是否存在，如果不存在才真正地创建实例
if(instance == null){
instance = new Singleton();
}
}
}
return instance;
}
}
这种实现方式可以实现既线程安全地创建实例，而又不会对性能造成太大的影响。它只是在第一次创建实例的时候同步，以后就不需要同步了，从而加快了运行速度。
================================================================
转自： http://2015.iteye.com/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;
}
调试发现
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>
不是一个内存地址，也就是不是同一个实体!
这是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实现，中规中矩。不过这种实现并不是线程安全的。所以各路大神都各显神威，给出了多种单例模式的实现。
现在把他加强下：
Java代码
static MyClass *class = nil;
@implementation MyClass
+(MyClass *)sharedMyClass{
@synchronized(self){ //为了确保多线程情况下，仍然确保实体的唯一性
if (!class) {
[[self alloc] init]; //该方法会调用 allocWithZone
}
}
return class;
}
+(id)allocWithZone:(NSZone *)zone{
@synchronized(self){// //为了确保多线程情况下，仍然确保实体的唯一性
if (!class) {
class = [super allocWithZone:zone]; //确保使用同一块内存地址
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; //确保计数唯一
}
- (unsigned)retainCount
{
return UINT_MAX; //装逼用的，这样打印出来的计数永远为-1
}
- (id)autorelease
{
return self;//确保计数唯一
}
- (oneway void)release
{
//重写计数释放方法 do nothing
}
@end
再调试
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>
都是指向同一块内存地址
-----------------------------------切糕分割线--------------------------------------------------------
然而这个人（http://eschatologist.net/blog/?p=178）觉的繁琐，所以给出如下实现：
Java代码
@interface SomeManager : NSObject
+ (id)sharedManager;
@end
/* 非线程安全的实现 */
@implementation SomeManager
+ (id)sharedManager {
static id sharedManager = nil;
if (sharedManager == nil) {
sharedManager = [[self alloc] init];
}
return sharedManager;
}
@end
/* 线程安全的实现 */
@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）实现单例。
Java代码
+(SchoolManager *)sharedInstance
{
__strong static SchoolManager *sharedManager;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
sharedManager = [[SchoolManager alloc] init];
});
return sharedManager;
}
函数void dispatch_once( dispatch_once_t *predicate, dispatch_block_t block);其中第一个参数predicate，该参数是检查后面第二个参数所代表的代码块是否被调用的谓词，第二个参数则是在整个应用程序中只会被调用一次的代码块。dispach_once函数中的代码块只会被执行一次，而且还是线程安全的。
看到如下一篇文章，用宏实现（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; \
