objective-c - Objective-C シングルトンはどのように見えるべきですか?

Question

私のシングルトンアクセサーメソッドは、通常、次の変形です。

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

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

Answer 1

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

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

したがって、次のようなことができます。

static MySingleton *sharedSingleton;

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

Answer 2

@interface MySingleton : NSObject
{
}

+ (MySingleton *)sharedSingleton;
@end

@implementation MySingleton

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

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

    return sharedSingleton;
  }
}

@end

[ソース]

Answer 3

以下の私の他の回答によると、私はあなたがやるべきだと思います：

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

Answer 4

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を試み、同時に存在しない場合、両方ともシングルトンの新しいインスタンスを初期化し、それを所定の位置に CAS しようとします。 sharedInstanceどちらが勝っても、CAS はすぐに戻ります。どちらが負けても、割り当てたばかりのインスタンスを解放し、 (now set) を返しますsharedInstance。シングルOSAtomicCompareAndSwapPtrBarrierは、設定スレッドの書き込みバリアと、テスト スレッドからの読み取りバリアの両方として機能します。

Answer 5

static MyClass * sharedInst = nil;

+（id）sharedInstance
{{
    @synchronize（self）{
        if（sharedInst == nil）{
            /*initで設定されたsharedInst*/
            [[自己割り当て]初期化];
        }
    }
    sharedInstを返します。
}

-（id）init
{{
    if（sharedInst！= nil）{
        [NSException raise：NSInternalInconsistencyException
            format：@ "[％@％@]を呼び出すことはできません。代わりに+ [％@％@]を使用してください"]、
            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を返します。
}

Answer 6

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

私が他の回答で読んだ初期化のすべての実装は、共通のエラーを共有しています。

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

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

Appleのドキュメントでは、初期化ブロックのクラスタイプを確認することを推奨しています。サブクラスはデフォルトで初期化を呼び出すためです。サブクラスが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に置き換えます。）

Answer 7

スレッドセーフですが、初期化後にロックしない 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;
}

Answer 8

簡単な答え: すばらしい。

長い答え: みたいな....

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 ヘッダーを必ず読んでください。この場合、ヘッダー コメントはドキュメントやマニュアル ページよりも適切です。

Answer 9

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

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

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

Answer 10

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

@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

Answer 11

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

Objective-C でシングルトン パターンを使用する

Answer 12

これはスレッドセーフであり、最初の呼び出しの後に高価なロックを避けるべきではありませんか?

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

Answer 13

どうですか

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

初期化後の同期コストを回避できますか?

Answer 14

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

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

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

コメント/寄稿を歓迎します。

Answer 15

KLSingleton は次のとおりです。

1. 下位分類可能 (n 次まで)
2. ARC対応
3. allocと安全init
4. 遅延ロード
5. スレッドセーフ
6. ロックフリー (@synchronize ではなく +initialize を使用)
7. マクロフリー
8. スウィズルフリー
9. 単純

KLシングルトン

Answer 16

私はすべての解決策を読んだわけではないので、このコードが冗長である場合はご容赦ください。

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

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

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

    return sharedResourcesObj;
}

Answer 17

自分自身で同期したくない...自分自身のオブジェクトがまだ存在しないため! 一時的な 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

Answer 18

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

Answer 19

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

[[Librarian sharedInstance] openLibrary]

に：

[Librarian openLibrary]

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

私はここでより詳細なブログを書きました:)

Answer 20

なくさないようにここに残しておきたいと思いました。これの利点は、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;
}

Answer 21

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

Answer 22

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

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 を取得したときにまだ初期化されていないことを確認することです。

Answer 23

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

以下は、私が見たいくつかの 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

ほとんど空であるのに、なぜインターフェイス マクロなのか? ヘッダー ファイルとコード ファイル間のコードの一貫性。自動メソッドを追加したり、変更したりする場合の保守性。

ここで最も人気のある回答（執筆時点）で使用されているように、初期化メソッドを使用してシングルトンを作成しています。

Answer 24

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

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

Apple のドキュメントごと:

... self の代わりに Class オブジェクトを使用して、関連するクラスのクラス メソッドを同期する同様のアプローチを取ることができます。

self を使用しても機能しないはずです。これは、コピーと貼り付けの間違いのように見えます。クラス ファクトリ メソッドの正しい実装は次のようになります。

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