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

https://stackoverflow.com/questions/145154

02-07-2019
|

質問

私のシングルトンアクセサメソッドは、通常、次のバリアントです：

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

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

解決

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

ランタイムは、プログラムの各クラスに initialize を1回送信します。クラスまたはそれを継承するクラスがプログラム内から最初のメッセージを送信する直前に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;                                                                        
}

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

高速ケース：通常の実行では sharedInstance はすでに設定されているため、 while ループは実行されず、変数の存在を単にテストしただけで関数が戻ります;
スローケース： sharedInstance が存在しない場合、インスタンスは割り当てられ、Compare And Swap（ 'CAS'）を使用してインスタンスにコピーされます;
競合するケース：2つのスレッドが両方とも sharedInstance を同時に呼び出そうとした場合、 AND sharedInstance は存在しません同時に、シングルトンの新しいインスタンスを初期化し、それを所定の位置にCASしようとします。 CASに勝った方はすぐに戻り、負けた方は割り当てたばかりのインスタンスを解放し、（現在設定されている） sharedInstance を返します。単一の OSAtomicCompareAndSwapPtrBarrier は、設定スレッドの書き込みバリアとテストスレッドの読み取りバリアの両方として機能します。

static MyClass *sharedInst = nil;

+ (id)sharedInstance
{
    @synchronize( self ) {
        if ( sharedInst == nil ) {
            /* sharedInst set up in init */
            [[self alloc] init];
        }
    }
    return sharedInst;
}

- (id)init
{
    if ( sharedInst != nil ) {
        [NSException raise:NSInternalInconsistencyException
            format:@"[%@ %@] cannot be called; use +[%@ %@] instead"],
            NSStringFromClass([self class]), NSStringFromSelector(_cmd), 
            NSStringFromClass([self class]),
            NSStringFromSelector(@selector(sharedInstance)"];
    } else if ( self = [super init] ) {
        sharedInst = self;
        /* Whatever class specific here */
    }
    return sharedInst;
}

/* These probably do nothing in
   a GC app.  Keeps singleton
   as an actual singleton in a
   non CG app
*/
- (NSUInteger)retainCount
{
    return NSUIntegerMax;
}

- (oneway void)release
{
}

- (id)retain
{
    return sharedInst;
}

- (id)autorelease
{
    return sharedInst;
}

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

他の回答で読んだinitializeのすべての実装は、一般的なエラーを共有しています。

+ (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のサブクラスを暗黙的に作成し、 + initialize の2回目のトリガーを実行します。

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

Singletonクラスに関する唯一の制限は、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の作品しかし、 Dave MacLachlanがここで説明するようにスウィズリングメソッドを使用するように実装を変更するGoogleの。

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

方法

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は：


サブクラス化可能（n次まで）

ARC互換性

alloc および init
で安全
遅延ロード

スレッドセーフ

ロックフリー（@synchronizeではなく+ initializeを使用）

マクロなし

スウィズルフリー

シンプル

KLSingleton

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

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

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

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

[[Librarian sharedInstance] openLibrary]

to：

[Librarian openLibrary]

クラスを Classメソッドだけを持つ別のクラスでラップすることにより、インスタンスを作成していないため、誤って重複したインスタンスを作成することはありません！

より詳細なブログこちら：）

@ 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のドキュメントごと：

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

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

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

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow