我的Objective-C单例应该长什么样？

这个代码应该是线程安全的，第一次调用后就避免了昂贵的锁定操作，是吗？

+ (MySingleton*)sharedInstance
{
    if (sharedInstance == nil) {
        @synchronized(self) {
            if (sharedInstance == nil) {
                sharedInstance = [[MySingleton alloc] init];
            }
        }
    }
    return (MySingleton *)sharedInstance;
}

关于Objective-C中单例模式的深入讨论，请参考此处：

在Objective-C中使用单例模式

这里是我整理的一个宏定义：

http://github.com/cjhanson/Objective-C-Optimized-Singleton

该宏定义基于Matt Gallagher的这篇文章，但改用Google的Dave MacLachlan所描述的方法交换实现方式。

欢迎评论和贡献。

这在非垃圾回收环境中也适用。

@interface MySingleton : NSObject {
}

+(MySingleton *)sharedManager;

@end


@implementation MySingleton

static MySingleton *sharedMySingleton = nil;

+(MySingleton*)sharedManager {
    @synchronized(self) {
        if (sharedMySingleton == nil) {
            [[self alloc] init]; // assignment not done here
        }
    }
    return sharedMySingleton;
}


+(id)allocWithZone:(NSZone *)zone {
    @synchronized(self) {
        if (sharedMySingleton == nil) {
            sharedMySingleton = [super allocWithZone:zone];
            return sharedMySingleton;  // assignment and return on first allocation
        }
    }
    return nil; //on subsequent allocation attempts return nil
}


-(void)dealloc {
    [super dealloc];
}

-(id)copyWithZone:(NSZone *)zone {
    return self;
}


-(id)retain {
    return self;
}


-(unsigned)retainCount {
    return UINT_MAX;  //denotes an object that cannot be release
}


-(void)release {
    //do nothing    
}


-(id)autorelease {
    return self;    
}


-(id)init {
    self = [super init];
    sharedMySingleton = self;

    //initialize here

    return self;
}

@end

如何呢？

static MyClass *gInstance = NULL;

+ (MyClass *)instance
{
    if (gInstance == NULL) {
        @synchronized(self)
        {
            if (gInstance == NULL)
                gInstance = [[self alloc] init];
        }
    }

    return(gInstance);
}

那么在初始化后，您就可以避免同步成本了吗？

KLSingleton 是：

1. 可无限子类化
2. 与 ARC 兼容
3. 在使用 alloc 和 init 时安全
4. 懒加载
5. 线程安全
6. 无锁（使用 +initialize，而非 @synchronize）
7. 无宏定义
8. 无方法交换
9. 简单易用

KLSingleton

延伸@robbie-hanson的例子...

static MySingleton* sharedSingleton = nil;

+ (void)initialize {
    static BOOL initialized = NO;
    if (!initialized) {
        initialized = YES;
        sharedSingleton = [[self alloc] init];
    }
}

- (id)init {
    self = [super init];
    if (self) {
        // Member initialization here.
    }
    return self;
}

只是想把这个留在这里，以免丢失。这个的优点是它可以在InterfaceBuilder中使用，这是一个巨大的优势。这是从我提出的另一个问题中获取的：

static Server *instance;

+ (Server *)instance { return instance; }

+ (id)hiddenAlloc
{
    return [super alloc];
}

+ (id)alloc
{
    return [[self instance] retain];
}


+ (void)initialize
{
    static BOOL initialized = NO;
    if(!initialized)
    {
        initialized = YES;
        instance = [[Server hiddenAlloc] init];
    }
}

- (id) init
{
    if (instance)
        return self;
    self = [super init];
    if (self != nil) {
        // whatever
    }
    return self;
}

通过Objective C类方法，我们可以避免使用单例模式的常规方式，从：

[[Librarian sharedInstance] openLibrary]

至：

[Librarian openLibrary]

通过将该类包装在另一个仅具有类方法的类中，就不会意外创建重复实例，因为我们没有创建任何实例！
我写了一篇更详细的博客这里 :)

我知道这个“问题”有很多评论，但我没有看到很多人建议使用宏来定义单例。这是一个非常常见的模式，宏极大地简化了单例。

这里是我根据几个Objc实现编写的宏。

Singeton.h

/**
 @abstract  Helps define the interface of a singleton.
 @param  TYPE  The type of this singleton.
 @param  NAME  The name of the singleton accessor.  Must match the name used in the implementation.
 @discussion
 Typcially the NAME is something like 'sharedThing' where 'Thing' is the prefix-removed type name of the class.
 */
#define SingletonInterface(TYPE, NAME) \
+ (TYPE *)NAME;


/**
 @abstract  Helps define the implementation of a singleton.
 @param  TYPE  The type of this singleton.
 @param  NAME  The name of the singleton accessor.  Must match the name used in the interface.
 @discussion
 Typcially the NAME is something like 'sharedThing' where 'Thing' is the prefix-removed type name of the class.
 */
#define SingletonImplementation(TYPE, NAME) \
static TYPE *__ ## NAME; \
\
\
+ (void)initialize \
{ \
    static BOOL initialized = NO; \
    if(!initialized) \
    { \
        initialized = YES; \
        __ ## NAME = [[TYPE alloc] init]; \
    } \
} \
\
\
+ (TYPE *)NAME \
{ \
    return __ ## NAME; \
}

使用示例：

MyManager.h

@interface MyManager

SingletonInterface(MyManager, sharedManager);

// ...

@end

MyManager.m

@implementation MyManager

- (id)init
{
    self = [super init];
    if (self) {
        // Initialization code here.
    }

    return self;
}

SingletonImplementation(MyManager, sharedManager);

// ...

@end

为什么在接口宏中几乎没有内容？这是为了保持头文件和代码文件之间的代码一致性，以及在需要添加更多自动方法或进行修改时的可维护性。
我正在使用初始化方法来创建单例，这是目前最流行的答案之一（截至撰写本文时）。