iOS 自毁单例设计模式

我最近遇到一个问题，其中我只希望特定对象存在一个实例，并且仅存在执行特定操作所需的短暂时间。它的操作是异步的，因此如果我没有保存对它的引用，ARC 会在运行循环结束时释放它。如果我确实保留它，我将需要委托回调或通知来知道何时完成释放它。

该对象需要下载多个图像和其他数据并将其缓存到磁盘。我不希望它在不缓存项目时浪费内存，因为缓存限制约为 24 小时。我也不需要它的任何反馈；我希望它能够执行它的任务并自行完成。

我想出了一个我非常喜欢的设计模式。从那时起，我在其他几个项目中使用了它，并且很好奇它是否是一个我不知道的众所周知且经过分析的模式（自毁单例？？？）。我想知道，这样我就可以了解我目前没有看到的任何潜在陷阱。

我也很想听听你们对为什么这是一个糟糕的设计的任何意见。

设计是这样的（这是 ARC，但如果通过类方法释放单例，非 ARC 也可以工作）：

全局静态对象（不是真正的单例，因为它并不是一直存在）

    static MySelfDestructingClass* singleton;

单个公共类方法

    + (void)downloadAndCacheDataIfNeeded
     {
        //Force synchronized access
        @synchronized(singleton){
            //We are already doing something, return
            if(singleton){
             return;
            }
             NSDate* lastCacheDate = [[NSUserDefaults standardDefaults] objectForKey:kKeyForLastUpdate];
            if([[NSDate date] timeIntervalSinceDate:lastCacheDate] > kCacheLimit){
              //Our cache is out of date, we need to update
                singleton = [[self alloc] init];
                [singleton downloadAndCache];
             }
        }
     }

现在我们的实例方法，我们需要我们的对象处于活动状态，以便请求可以返回：

      - (void)downloadAndCache
        {
               //This would probably be a delegate, but for simplicity of this example it's a notification
               [[NSNotificationCenter defaultCenter] addObserver:self forNotificationWithName:NotificationSomeRequestDidSucceed selector:@selector(someCustomRequestDidSucceed:withData:) object:nil];
               [SomeCustomRequest makeRequestWithURL:@"http://www.someURL.com"];

        }

      - (void)someCustomRequestDidSucceed:(SomeCustomRequest *)request withData:(NSDictionary *)dictionary
        {

             //Do whatever we need to in order to save our data, or fire off image download requests etc...
             ....


            //Set our lastUpdated time in NSUserDefaults
            [[NSUserDefaults standardDefaults] setObject:[NSDate date] forKey:kKeyForLastUpdate];

            //Remove our observer
            [NSNotificationCenter defaultCenter] removeObserver:self name:NotificationSomeRequestDidSucceed object:nil];

            //Release ourselves (ok not really, but tell arc we can be released)
            singleton = nil;
        } 

这样我在应用程序的其他任何地方所要做的就是：

     [MySelfDestructingClass downloadAndCacheDataIfNeeded];

现在，该对象将在需要时下载内容，并在完成后释放自身，或者根本不创建自身。它也不会开始两次下载数据。

我知道这种设计在可扩展性和功能方面存在局限性，但对于这样的实例以及我使用它的其他实例，我发现它非常有用。

这是很常见的使用块。考虑类似的东西（尽管我可能会以不同的方式处理多个调用......）

void ExecuteWithMySingleSelfDestructingObject(void(^block)(MySelfDestructingClass *object)) {
    static MySelfDestructingClass* singleton;
    @synchronized(singleton) {
        if (singleton) {
          // To get past the synchronization primitive, this must be a recursive call.
        }
        // Whatever other conditions you want to have (like your date check)
        singleton = [[MySelfDestructingClass] alloc] init];
        @try { block(singleton); }
        @finally { singleton = nil; }
    }
}

注意双重异常处理（try/finally 加上 @synchronized 的作用 - 可能想要改变这一点......

然后对块做任何你想做的事......

ExecuteWithMySingleSelfDestructingObject(^(MySelfDestructingClass *object){
    // Do whatever I want with the singleton instance that has
    // been given to me as <object>
});

当然，它可以是一个类方法......

+ (void)performBlock:(void(^)(MySelfDestructingClass *object))block {
    static MySelfDestructingClass* singleton;
    @synchronized(singleton) {
        if (singleton) {
          // To get past the synchronization primitive, this must be a recursive call.
        }
        // Whatever other conditions you want to have (like your date check)
        singleton = [[self] alloc] init];
        @try { block(singleton); }
        @finally { singleton = nil; }
    }
}

[MySelfDestructingClass performBlock:^(MySelfDestructingClass *object){
    // Do whatever I want with the singleton instance that has
    // been given to me as <object>
}];

我希望这是有道理的（我徒手输入的，所以语法可能会有所不同，但你应该明白）。