Question

我正在尝试编写一个我可以子类化为具有即时单例的类。这是我到目前为止所拥有的。它的工作原理是它的一个子类通过sharedInstance调用另一个子类，这会导致一个最终耗尽内存的巨大循环。

有什么想法吗？

static NSMutableDictionary *sharedInstances = nil;

@implementation Singleton

+ (Singleton*)sharedInstance
{
    [Singleton initSharedInstances];
    Class myClass = [self class];
    Singleton * sharedInstance = [sharedInstances objectForKey:myClass];
    @synchronized(myClass)
    {
        if (sharedInstance == nil)
        {
            sharedInstance = [[myClass alloc] init];
            [sharedInstances setObject:sharedInstance forKey:myClass];
        }
    }
    return sharedInstance;
}

+ (void) initSharedInstances
{
    if (sharedInstances == nil)
    {
        sharedInstances = [[NSMutableDictionary alloc] init];
    }
}

@end

Answer 1

你为什么要烦恼这一切？如果您试图通过覆盖-retain，-release，-retainCount和+allocWithZone:来强制执行超类中的单例行为，那么您正在做一些完全没有必要的事情。更简单的是提供+sharedInstance方法而不做任何其他事情。如果用户真的想要致电+alloc / -init，他们就可以，它们不会做得太好。有关框架中此类单例的示例，请查看NSUserDefaults和NSFileManager（尽管在后者的情况下，Apple实际上建议您忽略共享实例并分配/初始化您自己的实例NSFileManager）。

为了完成这个简单的共享实例，你需要做的只是在单例类中实现以下内容：

+ (id)sharedInstance {
    static MyClass sharedInstance;
    static dispatch_once_t predicate;
    dispatch_once(&predicate, ^{
        //sharedInstance = [[MyClass alloc] init];
        sharedInstance = [MyClass alloc];
        sharedInstance = [sharedInstance init];
    });
    return sharedInstance;
}

Answer 2

我正在尝试编写一个我可以子类化为具有即时单例的类。这是我到目前为止所拥有的。它的工作原理是它的一个子类通过sharedInstance调用另一个子类，这会导致一个最终耗尽内存的巨大循环。

这听起来像是在描述相互递归。如果subclass1调用subclass2而subclass2调用subclass1，那么你需要在某个地方打破循环，就像简单的自递归一样。

您的sharedInstance本身不应导致无限递归，除非您调用的init方法调用sharedInstance ...

Objective-C Singleton超类？

2 个答案: