Objective-Cシングルトンはどのように見えるべきですか？[閉まっている]

私のシングルトンアクセサーメソッドは通常、以下のバリアントです。

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

これを改善するために私は何ができますか？

別のオプションは、+(void)initializeメソッドを使用することです。ドキュメントから：

ランタイムinitializeは、プログラム内の各クラスに、クラスまたはそのクラスから継承するクラスにプログラムの最初のメッセージが送信される直前に1回だけ送信します。（したがって、クラスが使用されていない場合、メソッドが呼び出されることはありません。）ランタイムinitializeは、スレッドセーフな方法でクラスにメッセージを送信します。スーパークラスは、サブクラスの前にこのメッセージを受け取ります。

だからあなたはこれに似た何かをすることができます：

static MySingleton *sharedSingleton;

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

@interface MySingleton : NSObject
{
}

+ (MySingleton *)sharedSingleton;
@end

@implementation MySingleton

+ (MySingleton *)sharedSingleton
{
  static MySingleton *sharedSingleton;

  @synchronized(self)
  {
    if (!sharedSingleton)
      sharedSingleton = [[MySingleton alloc] init];

    return sharedSingleton;
  }
}

@end

[ソース]

以下の私の他の答えに従って、あなたはやるべきだと思います：

+ (id)sharedFoo
{
    static dispatch_once_t once;
    static MyFoo *sharedFoo;
    dispatch_once(&once, ^ { sharedFoo = [[self alloc] init]; });
    return sharedFoo;
}

Kendallはロックコストを回避しようとするスレッドセーフなシングルトンを投稿したので、私も1つ投げるつもりでした。

#import <libkern/OSAtomic.h>

static void * volatile sharedInstance = nil;                                                

+ (className *) sharedInstance {                                                                    
  while (!sharedInstance) {                                                                          
    className *temp = [[self alloc] init];                                                                 
    if(!OSAtomicCompareAndSwapPtrBarrier(0x0, temp, &sharedInstance)) {
      [temp release];                                                                                   
    }                                                                                                    
  }                                                                                                        
  return sharedInstance;                                                                        
}

さて、これがどのように機能するかを説明しましょう：

1. 速い場合：通常の実行でsharedInstanceはすでに設定されているため、whileループは実行されず、変数の存在をテストした後に関数が戻ります。

2. スローケース：sharedInstance存在しない場合は、インスタンスが割り当てられ、Compare And Swap（ 'CAS'）を使用してインスタンスにコピーされます。

3. コールへの2つのスレッドが試み両方の場合：ケースを競合sharedInstance同時にと sharedInstance同時に存在していない、彼らはシングルトンの新しいインスタンスを初期化し、所定の位置にCASにそれをしようと両方。CASを勝ち取った方はすぐに戻り、負けた方は割り当てたインスタンスを解放して（現在設定されている）を返しますsharedInstance。シングルOSAtomicCompareAndSwapPtrBarrierは、設定スレッドの書き込みバリアとテストスレッドの読み取りバリアの両方として機能します。

静的MyClass * sharedInst = nil;

+（id）sharedInstance
{
    @synchronize（self）{
        if（sharedInst == nil）{
            / * initに設定されたsharedInst * /
            [[self alloc] init];
        }
    }
    sharedInstを返します。
}

-（id）init
{
    if（sharedInst！= nil）{
        [NSExceptionレイズ：NSInternalInconsistencyException
            形式：@ "[％@％@]は呼び出せません。代わりに+ [％@％@]を使用してください"]、
            NSStringFromClass（[self class]）、NSStringFromSelector（_cmd）、 
            NSStringFromClass（[self class]）、
            NSStringFromSelector（@selector（sharedInstance） "];
    } else if（self = [super init]）{
        sharedInst = self;
        / *ここで特定のクラス* /
    }
    sharedInstを返します。
}

/ *これらはおそらく何もしません
   GCアプリ。シングルトンを維持
   の実際のシングルトンとして
   非CGアプリ
* /
-（NSUInteger）retainCount
{
    NSUIntegerMaxを返します。
}

-（一方向無効）リリース
{
}

-（id）retain
{
    sharedInstを返します。
}

-（id）autorelease
{
    sharedInstを返します。
}

編集：この実装はARCで廃止されました。ARCと互換性のあるObjective-Cシングルトンの実装方法をご覧ください。正しい実装のために。

他の回答で読んだすべての初期化の実装には、共通のエラーがあります。

+ (void) initialize {
  _instance = [[MySingletonClass alloc] init] // <----- Wrong!
}

+ (void) initialize {
  if (self == [MySingletonClass class]){ // <----- Correct!
      _instance = [[MySingletonClass alloc] init] 
  }
}

Appleのドキュメントでは、initializeブロックのクラスタイプを確認することをお勧めしています。サブクラスはデフォルトで初期化を呼び出すためです。サブクラスがKVOを介して間接的に作成される可能性のある自明ではないケースが存在します。別のクラスに次の行を追加した場合：

[[MySingletonClass getInstance] addObserver:self forKeyPath:@"foo" options:0 context:nil]

Objective-Cは、MySingletonClassのサブクラスを暗黙的に作成し、2回目のトリガーを引き起こし+initializeます。

次のように、initブロックで初期化の重複を暗黙的にチェックする必要があると考えるかもしれません。

- (id) init { <----- Wrong!
   if (_instance != nil) {
      // Some hack
   }
   else {
      // Do stuff
   }
  return self;
}

しかし、あなたは足で自分を撃ちます。またはさらに悪いことに、他の開発者に自分の足を撃つ機会を与える。

- (id) init { <----- Correct!
   NSAssert(_instance == nil, @"Duplication initialization of singleton");
   self = [super init];
   if (self){
      // Do stuff
   }
   return self;
}

TL; DR、これが私の実装です

@implementation MySingletonClass
static MySingletonClass * _instance;
+ (void) initialize {
   if (self == [MySingletonClass class]){
      _instance = [[MySingletonClass alloc] init];
   }
}

- (id) init {
   ZAssert (_instance == nil, @"Duplication initialization of singleton");
   self = [super init];
   if (self) {
      // Initialization
   }
   return self;
}

+ (id) getInstance {
   return _instance;
}
@end

（ZAssertを独自のアサーションマクロ、または単にNSAssertに置き換えます。）

シングルトンマクロコードの詳細な説明は、ブログCocoa With Loveにあります。

http://cocoawithlove.com/2008/11/singletons-appdelegates-and-top-level.html。

スレッドセーフですが、初期化後にロックされないsharedInstanceに興味深いバリエーションがあります。要求に応じて上位の回答を変更するのに十分かどうかはまだわかりませんが、さらに議論するために提示します。

// Volatile to make sure we are not foiled by CPU caches
static volatile ALBackendRequestManager *sharedInstance;

// There's no need to call this directly, as method swizzling in sharedInstance
// means this will get called after the singleton is initialized.
+ (MySingleton *)simpleSharedInstance
{
    return (MySingleton *)sharedInstance;
}

+ (MySingleton*)sharedInstance
{
    @synchronized(self)
    {
        if (sharedInstance == nil)
        {
            sharedInstance = [[MySingleton alloc] init];
            // Replace expensive thread-safe method 
            // with the simpler one that just returns the allocated instance.
            SEL origSel = @selector(sharedInstance);
            SEL newSel = @selector(simpleSharedInstance);
            Method origMethod = class_getClassMethod(self, origSel);
            Method newMethod = class_getClassMethod(self, newSel);
            method_exchangeImplementations(origMethod, newMethod);
        }
    }
    return (MySingleton *)sharedInstance;
}

短い答え：すばらしい。

長い答え：次のようなもの...

static SomeSingleton *instance = NULL;

@implementation SomeSingleton

+ (id) instance {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        if (instance == NULL){
            instance = [[super allocWithZone:NULL] init];
        }
    });
    return instance;
}

+ (id) allocWithZone:(NSZone *)paramZone {
    return [[self instance] retain];
}

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

- (id) autorelease {
    return self;
}

- (NSUInteger) retainCount {
    return NSUIntegerMax;
}

- (id) retain {
    return self;
}

@end

何が起こっているのかを理解するには、必ずdispatch / once.hヘッダーを読んでください。この場合、ヘッダーコメントは、ドキュメントやマニュアルページよりも適切です。

シングルトンをクラスにまとめたので、他のクラスはシングルトンプロパティを継承できます。

Singleton.h：

static id sharedInstance = nil;

#define DEFINE_SHARED_INSTANCE + (id) sharedInstance {  return [self sharedInstance:&sharedInstance]; } \
                               + (id) allocWithZone:(NSZone *)zone { return [self allocWithZone:zone forInstance:&sharedInstance]; }

@interface Singleton : NSObject {

}

+ (id) sharedInstance;
+ (id) sharedInstance:(id*)inst;

+ (id) allocWithZone:(NSZone *)zone forInstance:(id*)inst;

@end

Singleton.m：

#import "Singleton.h"


@implementation Singleton


+ (id) sharedInstance { 
    return [self sharedInstance:&sharedInstance];
}

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

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

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

- (id)retain {
    return self;
}

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

- (void)release {
    //do nothing
}

- (id)autorelease {
    return self;
}


@end

そして、これがシングルトンになりたいクラスの例です。

#import "Singleton.h"

@interface SomeClass : Singleton {

}

@end

@implementation SomeClass 

DEFINE_SHARED_INSTANCE;

@end

シングルトンクラスに関する唯一の制限は、それがNSObjectサブクラスであることです。しかし、ほとんどの場合、コードでシングルトンを使用します。シングルトンは実際にはNSObjectのサブクラスであるため、このクラスを使用すると、私の生活が非常に簡単になり、コードがすっきりします。

これはガベージコレクションされていない環境でも機能します。

@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

これはスレッドセーフであり、最初の呼び出し後の高価なロックを回避しないのですか？

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

ここに私がまとめたマクロがあります：

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

これはMatt Gallagherによるここの作業に基づいていますが、GoogleのDave MacLachlanによってここで説明 されているように、メソッドのスウィズリングを使用するように実装を変更しています。

コメント/貢献を歓迎します。

いかがですか

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

初期化後の同期コストを回避しますか？

Objective-Cのシングルトンパターンの詳細については、こちらをご覧ください。

Objective-Cでのシングルトンパターンの使用

KLSingletonは：

1. サブ分類可能（n次まで）
2. ARC互換
3. セーフallocとinit
4. 遅延読み込み
5. スレッドセーフ
6. ロックフリー（@同期ではなく+ initializeを使用）
7. マクロフリー
8. スウィズルフリー
9. シンプルな

KLSingleton

セルフで同期したくない...セルフオブジェクトがまだ存在しないため！一時的なid値をロックしてしまいます。他のユーザーがクラスメソッド（sharedInstance、alloc、allocWithZone：など）を実行できないようにしたいので、代わりにクラスオブジェクトで同期する必要があります。

@implementation MYSingleton

static MYSingleton * sharedInstance = nil;

+( id )sharedInstance {
    @synchronized( [ MYSingleton class ] ) {
        if( sharedInstance == nil )
            sharedInstance = [ [ MYSingleton alloc ] init ];
    }

    return sharedInstance;
}

+( id )allocWithZone:( NSZone * )zone {
    @synchronized( [ MYSingleton class ] ) {
        if( sharedInstance == nil )
            sharedInstance = [ super allocWithZone:zone ];
    }

    return sharedInstance;
}

-( id )init {
    @synchronized( [ MYSingleton class ] ) {
        self = [ super init ];
        if( self != nil ) {
            // Insert initialization code here
        }

        return self;
    }
}

@end

これをここに置いておきたかったので、私はそれを失うことはありません。これの利点は、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;
}

static mySingleton *obj=nil;

@implementation mySingleton

-(id) init {
    if(obj != nil){     
        [self release];
        return obj;
    } else if(self = [super init]) {
        obj = self;
    }   
    return obj;
}

+(mySingleton*) getSharedInstance {
    @synchronized(self){
        if(obj == nil) {
            obj = [[mySingleton alloc] init];
        }
    }
    return obj;
}

- (id)retain {
    return self;
}

- (id)copy {
    return self;
}

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

- (void)release {
    if(obj != self){
        [super release];
    }
    //do nothing
}

- (id)autorelease {
    return self;
}

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

私はこの「質問」についてたくさんのコメントがあることを知っていますが、シングルトンを定義するためにマクロを使用することを提案する多くの人々を見かけません。これは一般的なパターンであり、マクロはシングルトンを大幅に簡素化します。

これが私が見たいくつかの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

ほぼ空のインターフェイスマクロを使用するのはなぜですか？ヘッダーとコードファイル間のコードの整合性。自動メソッドを追加したり、変更したりする場合の保守性。

この記事の執筆時点で最も一般的な回答で使用されているように、initializeメソッドを使用してシングルトンを作成しています。

Objective Cクラスのメソッドを使用すると、シングルトンパターンを通常の方法で使用することを回避できます。

[[Librarian sharedInstance] openLibrary]

に：

[Librarian openLibrary]

クラスメソッドのみを持つ別のクラス内にクラスをラップすることにより、インスタンスを作成しないため、誤って重複インスタンスを作成する可能性がなくなります。

私はここにもっと詳細なブログを書いた:)

@ 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;
}

私の方法は次のように簡単です：

static id instanceOfXXX = nil;

+ (id) sharedXXX
{
    static volatile BOOL initialized = NO;

    if (!initialized)
    {
        @synchronized([XXX class])
        {
            if (!initialized)
            {
                instanceOfXXX = [[XXX alloc] init];
                initialized = YES;
            }
        }
    }

    return instanceOfXXX;
}

シングルトンがすでに初期化されている場合、LOCKブロックは開始されません。2番目のチェックif（！initialized）は、現在のスレッドがLOCKを取得したときにまだ初期化されていないことを確認することです。

私はすべてのソリューションを読んだわけではないので、このコードが冗長である場合は許してください。

これは私の意見では最もスレッドセーフな実装です。

+(SingletonObject *) sharedManager
{
    static SingletonObject * sharedResourcesObj = nil;

    @synchronized(self)
    {
        if (!sharedResourcesObj)
        {
            sharedResourcesObj = [[SingletonObject alloc] init];
        }
    }

    return sharedResourcesObj;
}

私は通常、Ben Hoffsteinの回答とほぼ同じようなコードを使用します（これもWikipediaから取得しました）。私は、Chris Hansonのコメントで述べられた理由でそれを使用します。

ただし、NIBにシングルトンを配置する必要がある場合があり、その場合は以下を使用します。

@implementation Singleton

static Singleton *singleton = nil;

- (id)init {
    static BOOL initialized = NO;
    if (!initialized) {
        self = [super init];
        singleton = self;
        initialized = YES;
    }
    return self;
}

+ (id)allocWithZone:(NSZone*)zone {
    @synchronized (self) {
        if (!singleton)
            singleton = [super allocWithZone:zone];     
    }
    return singleton;
}

+ (Singleton*)sharedSingleton {
    if (!singleton)
        [[Singleton alloc] init];
    return singleton;
}

@end

-retain上記のコードはガベージコレクション環境で必要なすべてですが、私は（など）の実装を読者に任せています。

受け入れられた答えは、コンパイルされていますが、正しくありません。

+ (MySingleton*)sharedInstance
{
    @synchronized(self)  <-------- self does not exist at class scope
    {
        if (sharedInstance == nil)
            sharedInstance = [[MySingleton alloc] init];
    }
    return sharedInstance;
}

Appleのドキュメントごと：

...同様の方法で、自己の代わりにClassオブジェクトを使用して、関連するクラスのクラスメソッドを同期させることができます。

セルフワークを使用していても、それはすべきではなく、コピーアンドペーストのミスのように見えます。クラスファクトリメソッドの正しい実装は次のとおりです。

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