Objective-C 싱글 톤은 어떻게 생겼나요? [닫은]

내 싱글 톤 접근 자 방법은 일반적으로 다음과 같은 변형입니다.

static MyClass *gInstance = NULL;

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

    return(gInstance);
}

이것을 개선하기 위해 무엇을 할 수 있습니까?

다른 옵션은이 +(void)initialize방법 을 사용하는 것입니다. 설명서에서 :

런타임은 initialize클래스 바로 전에 한 번만 프로그램의 각 클래스로 보내 거나 클래스에서 상속 된 모든 클래스가 프로그램 내에서 첫 번째 메시지를 보냅니다. 클래스가 사용되지 않으면 메소드가 호출되지 않을 수 있습니다. 런타임은 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;
}

이후 켄달 게시 비용을 잠금 방지하기 위해 그 시도 싱글 스레드 세이프를, 내가 아니라 하나를 던져 것이라고 생각 :

#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. 경합 경우 : 두 개의 스레드 호출에 모두 시도하면 sharedInstance같은 시간에 와 sharedInstance 같은 시간에 존재하지 않는 다음 그들이 싱글 모두 초기화 새로운 인스턴스와 위치에 CAS 그것을 시도합니다. 어느 쪽이 CAS에 당첨 되든 즉시 반환, 둘 중 하나는 방금 할당 한 인스턴스를 해제하고 (현재 설정)을 반환합니다 sharedInstance. 단일 OSAtomicCompareAndSwapPtrBarrier은 설정 스레드의 쓰기 장벽과 테스트 스레드의 읽기 장벽 역할을합니다.

정적 MyClass * sharedInst = nil;

+ (id) shared 인스턴스
{
    @synchronize (자체) {
        if (sharedInst == nil) {
            / * sharedInst 설정 init * /
            [[자체 할당] init];
        }
    }
    return sharedInst;
}

-(ID) 초기화
{
    if (sharedInst! = nil) {
        [NSException raise : NSInternalInconsistencyException
            형식 : @ "[% @ % @]을 (를) 호출 할 수 없습니다. 대신 + [% @ % @] 사용"],
            NSStringFromClass ([self class]), NSStringFromSelector (_cmd), 
            NSStringFromClass ([자체 클래스]),
            NSStringFromSelector (@selector (sharedInstance) "];
    } else if (self = [super init]) {
        sharedInst = 자기;
        / * 여기에 특정 클래스가 무엇이든 * /
    }
    return sharedInst;
}

/ * 이것들은 아마 아무것도하지 않습니다
   GC 앱. 싱글 톤 유지
   실제 싱글 톤으로
   비 CG 앱
* /
-(NSUInteger) 유지 횟수
{
    NSUIntegerMax를 반환합니다.
}

-(일방 통행) 해제
{
}

-(id) 유지
{
    return sharedInst;
}

-(ID) 자동 출시
{
    return 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의 서브 클래스를 작성하여 두 번째 트리거를 발생 +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

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의 작품을 기반으로 하지만 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. 아크 호환
3. 와 안전 alloc과init
4. 느리게로드
5. 스레드 안전
6. 잠금 해제 (@synchronize가 아닌 + 초기화 사용)
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]

Class Methods 만있는 다른 클래스 안에 클래스를 래핑하면 인스턴스를 만들지 않으므로 실수로 중복 인스턴스를 만들 가능성이 없습니다!

나는 여기에 더 자세한 블로그를 썼습니다 :)

@ 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 블록이 입력되지 않습니다. 두 번째 검사 if (! initialized)는 현재 스레드가 LOCK을 얻을 때 아직 초기화되지 않았는지 확인하는 것입니다.

모든 솔루션을 읽지 않았 으므로이 코드가 중복되면 용서하십시오.

이것은 제 생각에 가장 안전한 스레드 구현입니다.

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

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

    return sharedResourcesObj;
}

나는 보통 벤 호프 슈타인의 답변과 비슷한 코드를 사용합니다 (또한 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;
}