ARC와 호환되는 Objective-C 싱글 톤을 어떻게 구현합니까?

Xcode 4.2에서 자동 참조 카운팅 (ARC)을 사용할 때 올바르게 컴파일되고 동작하는 싱글 톤 클래스를 어떻게 변환 (또는 작성)합니까?

당신이 이미하고있는 것과 똑같은 방식으로 :

+ (instancetype)sharedInstance
{
    static MyClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[MyClass alloc] init];
        // Do any other initialisation stuff here
    });
    return sharedInstance;
}

필요에 따라 다른 인스턴스를 작성하려면 다음을 수행하십시오.

+ (MyClass *)sharedInstance
{
    static MyClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[MyClass alloc] init];
        // Do any other initialisation stuff here
    });
    return sharedInstance;
}

그렇지 않으면 다음을 수행해야합니다.

+ (id)allocWithZone:(NSZone *)zone
{
    static MyClass *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [super allocWithZone:zone];
    });
    return sharedInstance;
}

ARC 및 비 ARC 용 버전입니다.

사용하는 방법:

MySingletonClass.h

@interface MySingletonClass : NSObject

+(MySingletonClass *)sharedInstance;

@end

MySingletonClass.m

#import "MySingletonClass.h"
#import "SynthesizeSingleton.h"
@implementation MySingletonClass
SYNTHESIZE_SINGLETON_FOR_CLASS(MySingletonClass)
@end

이것은 ARC에서 제 패턴입니다. GCD를 사용하여 새로운 패턴을 만족시키고 Apple의 오래된 인스턴스화 방지 패턴도 만족시킵니다.

@implementation AAA
+ (id)alloc
{
    return  [self allocWithZone:nil];
}
+ (id)allocWithZone:(NSZone *)zone
{
    [self doesNotRecognizeSelector:_cmd];
    abort();
}
+ (instancetype)theController
{
    static AAA* c1  =   nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^
    {
        c1  =   [[super allocWithZone:nil] init];

        // For confirm...       
        NSLog(@"%@", NSStringFromClass([c1 class]));    //  Prints AAA
        NSLog(@"%@", @([c1 class] == self));            //  Prints 1

        Class   real_superclass_obj =   class_getSuperclass(self);
        NSLog(@"%@", @(real_superclass_obj == self));   //  Prints 0
    });

    return  c1;
}
@end

이 답변을 읽고 다른 답변을 읽으십시오.

솔루션을 이해하지 못하는 것보다 싱글 톤의 의미와 요구 사항이 무엇인지 이해해야합니다.

싱글 톤을 성공적으로 만들려면 다음 3을 수행 할 수 있어야합니다.

• 경쟁 조건 이있는 경우 여러 SharedInstance 인스턴스를 동시에 만들 수 없어야합니다!
• 여러 번의 호출 중 가치를 기억하고 유지하십시오.
• 한 번만 작성하십시오. 진입 점을 제어합니다.

dispatch_once_t블록을 한 번만 전달 하여 경쟁 조건 을 해결하는 데 도움이됩니다 .

Static여러 번의 호출에서 값을 "기억"하는 데 도움이됩니다. 어떻게 기억합니까? 정확한 이름의 sharedInstance를 가진 새 인스턴스를 다시 만들 수는 없으며 원래 만들어진 인스턴스와 만 작동합니다.

sharedInstance 클래스에서 호출을 사용하지 않고alloc init (즉 alloc init, NSObject 서브 클래스이므로 메소드를 사용하지 않아야 함) +(instancetype)sharedInstance, 다른 스레드의 다중 시도에 관계없이 한 번만 시작 하도록 제한 되는을 사용하여이를 달성 합니다. 동시에 그 가치를 기억하십시오.

코코아 자체와 함께 제공되는 가장 일반적인 시스템 싱글 톤은 다음과 같습니다.

• [UIApplication sharedApplication]
• [NSUserDefaults standardUserDefaults]
• [NSFileManager defaultManager]
• [NSBundle mainBundle]
• [NSOperations mainQueue]
• [NSNotificationCenter defaultCenter]

기본적으로 중앙 집중식 효과가 필요한 것은 일종의 싱글 톤 디자인 패턴을 따라야합니다.

또는 Objective-C는 NSObject 및 모든 하위 클래스에 + (void) initialize 메소드를 제공합니다. 항상 클래스의 메소드보다 먼저 호출됩니다.

iOS 6에서 중단 점을 한 번에 설정했으며 dispatch_once가 스택 프레임에 나타났습니다.

싱글 톤 클래스 : 어떤 경우에도 또는 어떤 방식으로도 둘 이상의 클래스 객체를 만들 수 없습니다.

+ (instancetype)sharedInstance
{
    static ClassName *sharedInstance = nil;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        sharedInstance = [[ClassName alloc] init];
        // Perform other initialisation...
    });
    return sharedInstance;
}
//    You need need to override init method as well, because developer can call [[MyClass alloc]init] method also. that time also we have to return sharedInstance only. 

-(MyClass)init
{
   return [ClassName sharedInstance];
}

허용되는 답변에는 두 가지 문제가 있으며, 귀하의 목적과 관련이있을 수도 있고 그렇지 않을 수도 있습니다.

1. init 메소드에서 어떻게 든 sharedInstance 메소드가 다시 호출되면 (예를 들어 싱글 톤을 사용하는 다른 객체가 구성되어 있기 때문에) 스택 오버플로가 발생합니다.
2. 클래스 계층의 경우 계층의 콘크리트 클래스 당 하나의 싱글 톤이 아닌 단일 톤 (즉, sharedInstance 메소드가 호출 된 계층의 첫 번째 클래스) 만 있습니다.

다음 코드는이 두 문제를 모두 처리합니다.

+ (instancetype)sharedInstance {
    static id mutex = nil;
    static NSMutableDictionary *instances = nil;

    //Initialize the mutex and instances dictionary in a thread safe manner
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        mutex = [NSObject new];
        instances = [NSMutableDictionary new];
    });

    id instance = nil;

    //Now synchronize on the mutex
    //Note: do not synchronize on self, since self may differ depending on which class this method is called on
    @synchronized(mutex) {
        id <NSCopying> key = (id <NSCopying>)self;
        instance = instances[key];
        if (instance == nil) {
            //Break allocation and initialization into two statements to prevent a stack overflow, if init somehow calls the sharedInstance method
            id allocatedInstance = [self alloc];

            //Store the instance into the dictionary, one per concrete class (class acts as key for the dictionary)
            //Do this right after allocation to avoid the stackoverflow problem
            if (allocatedInstance != nil) {
                instances[key] = allocatedInstance;
            }
            instance = [allocatedInstance init];

            //Following code may be overly cautious
            if (instance != allocatedInstance) {
                //Somehow the init method did not return the same instance as the alloc method
                if (instance == nil) {
                    //If init returns nil: immediately remove the instance again
                    [instances removeObjectForKey:key];
                } else {
                    //Else: put the instance in the dictionary instead of the allocatedInstance
                    instances[key] = instance;
                }
            }
        }
    }
    return instance;
}

#import <Foundation/Foundation.h>

@interface SingleTon : NSObject

@property (nonatomic,strong) NSString *name;
+(SingleTon *) theSingleTon;

@end

#import "SingleTon.h"
@implementation SingleTon

+(SingleTon *) theSingleTon{
    static SingleTon *theSingleTon = nil;

    if (!theSingleTon) {

        theSingleTon = [[super allocWithZone:nil] init
                     ];
    }
    return theSingleTon;
}

+(id)allocWithZone:(struct _NSZone *)zone{

    return [self theSingleTon];
}

-(id)init{

    self = [super init];
    if (self) {
        // Set Variables
        _name = @"Kiran";
    }

    return self;
}

@end

위의 코드가 도움이 될 것입니다.

싱글 톤을 신속하게 만들어야하는 경우

class var sharedInstance: MyClass {
    struct Singleton {
        static let instance = MyClass()
    }
    return Singleton.instance
}

또는

struct Singleton {
    static let sharedInstance = MyClass()
}

class var sharedInstance: MyClass {
    return Singleton.sharedInstance
}

이 방법으로 사용할 수 있습니다

let sharedClass = LibraryAPI.sharedInstance