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が投稿した ロックコストを回避しようとするスレッドセーフなシングルトンなので、私も同様にそれを放棄すると思いました：
#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を同時に呼び出そうとするとsharedInstanceが同時に存在しない場合、両方とも初期化されます。シングルトンの新しいインスタンスを作成し、それを正しい位置にCASしようとします。どちらが勝ってもすぐにCASが返ってきた方、負けた方が割り当てたばかりのインスタンスを解放し、（現在設定されている）sharedInstanceを返します。単一のOSAtomicCompareAndSwapPtrBarrierは、設定スレッドの書き込みバリアとテストスレッドからの読み取りバリアの両方として機能します。
static 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） "];
}その他の場合（self = [super init]）{[。 sharedInst = self;
/*ここで特定のクラスはすべて*/
}
return sharedInst;
}
/*これらはおそらくGCアプリの中では何もしません。
非CGアプリの実際のシングルトンとしてのシングルトン
*/
- （NSUInteger）retainCount
{
return NSUIntegerMax [
]}
- （片道無効）リリース
{
}
- （id）保持
{
sharedInstを返す;
}
- （id）自動解放
{
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のサブクラスが作成され、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 header を必ず読んでください。この場合、ヘッダーのコメントはdocsやmanページよりも適切です。
シングルトンをクラスにまとめたので、他のクラスはシングルトンプロパティを継承できます。
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サブクラスなので、このクラスは私の生活を本当に楽にし、コードをきれいにします。
これはスレッドセーフではなく、最初の呼び出し後の高価なロックを避けるべきですか？
+ (MySingleton*)sharedInstance
{
if (sharedInstance == nil) {
@synchronized(self) {
if (sharedInstance == nil) {
sharedInstance = [[MySingleton alloc] init];
}
}
}
return (MySingleton *)sharedInstance;
}
これは、ガベージコレクションされていない環境でも機能します。
@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);
}
それで、あなたは初期化の後の同期コストを避けますか？
Objective-Cのシングルトンパターンの詳細については、こちらを参照してください。
これがマクロです 私がまとめると：
http://github.com/cjhanson/Objective-C-Optimized-Singleton
それはに基づいています ここでの作業はMatt Gallagherによるものです しかし使用する実装を変更する ここではGoogleのDave MacLachlanによって説明されているような方法を使っています 。
私はコメント/貢献を歓迎します。
KLSingletonは以下のとおりです。
- 下位分類可能（n次まで）
- ARC互換
allocおよびinitで安全- 遅延ロード
- スレッドセーフ
- ロックフリー（@synchronizeではなく+ initializeを使用）
- マクロフリー
- スウィズルフリー
- 単純な
この「質問」について多くのコメントがあることは知っていますが、シングルトンを定義するためにマクロを使用することを提案している人は多くいません。これは非常に一般的なパターンであり、マクロはシングルトンを非常に単純化します。
これが私が見たいくつかの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;
}
あなたは自分自身で同期したくありません...自分自身のオブジェクトはまだ存在していないので！あなたは一時的な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
私のやり方はこんな感じです：
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番目のチェック（！initialization）は、現在のスレッドがLOCKを取得したときにまだ初期化されていないことを確認するためのものです。
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
負けないようにここに置いておきたかっただけです。これの利点は、それが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;
}
すべての解決策を読み終えたわけではないので、このコードが重複している場合はご容赦ください。
これは私の考えでは最もスレッドセーフな実装です。
+(SingletonObject *) sharedManager
{
static SingletonObject * sharedResourcesObj = nil;
@synchronized(self)
{
if (!sharedResourcesObj)
{
sharedResourcesObj = [[SingletonObject alloc] init];
}
}
return sharedResourcesObj;
}