ios - 单例属性根据调用返回不同的值

Question

背景

在我的应用程序中，我有一个名为 FavoritesController 的类，用于管理用户标记为收藏夹的对象，然后在整个应用程序中使用此收藏夹状态。 FavoritesController 被设计为单例类，因为整个应用程序中有许多 UI 元素需要了解不同位置对象的“收藏夹状态”，网络请求也需要能够发出收藏夹需要失效的信号如果服务器这样说。

这个失效部分发生在服务器响应 404 错误时，表明必须从用户的收藏夹中删除收藏的对象。网络获取函数抛出错误，触发 FavoritesController 删除对象，然后向感兴趣的各方发送通知，告知他们需要刷新。

问题

当使用单元测试检查 404 实现的质量时，所有方法都按预期触发 - 错误被抛出并被捕获，FavoritesController 删除对象并发送通知。但在某些情况下，已删除的收藏夹仍然存在 - 但这取决于从何处完成查询!

如果我在单例中查询，删除就成功了，但如果我从一个使用单例的类中查询，删除就没有发生。

设计细节

• FavoritesController 属性 favorites 使用具有所有访问权限的 ivar @synchronized()，并且 ivar 的值由 NSUserDefaults 属性支持。
• 最喜欢的对象是具有两个键的 NSDictionary:id 和 name。

其他信息

• 一件我不明白为什么会发生的奇怪事情:在一些删除尝试中，最喜欢的对象的 name 值被设置为 "" 但是id 键保留其值。

• 我编写了单元测试来添加无效的收藏夹并检查它是否在第一次服务器查询时被删除。当从空的收藏夹开始时，此测试通过，但当存在上述“半删除”对象的实例时失败(保留其 id 值)

• 单元测试现在始终通过，但在实际使用中，删除失败仍然存在。我怀疑这是因为 NSUserDefaults 没有立即保存到磁盘。

我尝试过的步骤

• 确保单例实现是“真正的”单例，即 sharedController 始终返回相同的实例。
• 我认为存在某种“捕获”问题，闭包会保留自己的副本以及过时的收藏夹，但我认为不会。当 NSLogging 对象 ID 时，它返回相同的值。

代码

FavoritesController主要方法

- (void) serverCanNotFindFavorite:(NSInteger)siteID {

    NSLog(@"Server can't find favorite");
    NSDictionary * removedFavorite = [NSDictionary dictionaryWithDictionary:[self favoriteWithID:siteID]];
    NSUInteger index = [self indexOfFavoriteWithID:siteID];
    [self debugLogFavorites];

    dispatch_async(dispatch_get_main_queue(), ^{

        [self removeFromFavorites:siteID completion:^(BOOL success) {
            if (success) {
                NSNotification * note = [NSNotification notificationWithName:didRemoveFavoriteNotification object:nil userInfo:@{@"site" : removedFavorite, @"index" : [NSNumber numberWithUnsignedInteger:index]}];
                NSLog(@"Will post notification");
            
                [self debugLogFavorites];
                [self debugLogUserDefaultsFavorites];
                [[NSNotificationCenter defaultCenter] postNotification:note];
                NSLog(@"Posted notification with name: %@", didRemoveFavoriteNotification);
            }
        }];
    });

}

- (void) removeFromFavorites:(NSInteger)siteID completion:(completionBlock) completion {
    if ([self isFavorite:siteID]) {
        NSMutableArray * newFavorites = [NSMutableArray arrayWithArray:self.favorites];
    
        NSIndexSet * indices = [newFavorites indexesOfObjectsPassingTest:^BOOL(NSDictionary * entryUnderTest, NSUInteger idx, BOOL * _Nonnull stop) {
            NSNumber * value = (NSNumber *)[entryUnderTest objectForKey:@"id"];
            if ([value isEqualToNumber:[NSNumber numberWithInteger:siteID]]) {
                return YES;
            }
            return NO;
        }];
    
        __block NSDictionary* objectToRemove = [[newFavorites objectAtIndex:indices.firstIndex] copy];
    
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"Will remove %@", objectToRemove);
            [newFavorites removeObject:objectToRemove];
            [self setFavorites:[NSArray arrayWithArray:newFavorites]];

            if ([self isFavorite:siteID]) {
                NSLog(@"Failed to remove!");
            
                if (completion) {
                    completion(NO);
                }
            } else {
                NSLog(@"Removed OK");
                
                if (completion) {
                    completion(YES);
                }
            }
        });
    
    } else {
        NSLog(@"Tried removing site %li which is not a favorite", (long)siteID);
        if (completion) {
            completion(NO);
        }
    }
}

- (NSArray *) favorites
{
    @synchronized(self) {
        if (!internalFavorites) {
            static dispatch_once_t onceToken;
            dispatch_once(&onceToken, ^{
                self->internalFavorites = [self.defaults objectForKey:k_key_favorites];
            });
            if (!internalFavorites) {
                internalFavorites = [NSArray array];
            }
        }
        
        return internalFavorites;
    }

}

- (void) setFavorites:(NSArray *)someFavorites {

    @synchronized(self) {
        internalFavorites = someFavorites;
    [self.defaults setObject:internalFavorites forKey:k_key_favorites];
    }


}

- (void) addToFavorites:(NSInteger)siteID withName:(NSString *)siteName {
    if (![self isFavorite:siteID]) {
        NSDictionary * newFavorite = @{
                                       @"name"  : siteName,
                                       @"id"    : [NSNumber numberWithInteger:siteID]
                                   };
        dispatch_async(dispatch_get_main_queue(), ^{
            NSArray * newFavorites = [self.favorites arrayByAddingObject:newFavorite];
            [self setFavorites:newFavorites];

        });
    
        NSLog(@"Added site %@ with id %ld to favorites", siteName, (long)siteID);
    
    } else {
        NSLog(@"Tried adding site as favorite a second time");
    }
}

- (BOOL) isFavorite:(NSInteger)siteID
{
 
    @synchronized(self) {
        
        NSNumber * siteNumber = [NSNumber numberWithInteger:siteID];
        NSArray * favs = [NSArray arrayWithArray:self.favorites];
        if (favs.count == 0) {
            NSLog(@"No favorites");
            return NO;
        }
        
        NSIndexSet * indices = [favs indexesOfObjectsPassingTest:^BOOL(NSDictionary * entryUnderTest, NSUInteger idx, BOOL * _Nonnull stop) {
            if ([[entryUnderTest objectForKey:@"id"] isEqualToNumber:siteNumber]) {
                return YES;
            }
            
            return NO;
        }];
        
        if (indices.count > 0) {
            return YES;
        }
    }
    
    return NO;
}

FavoritesController 的单例实现

- (instancetype) init {
    static PKEFavoritesController *initedObject;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        initedObject = [super init];
        self.defaults = [NSUserDefaults standardUserDefaults];
    });
    return initedObject;
}

+ (instancetype) sharedController
{
    return [self new];
}

单元测试代码

func testObsoleteFavoriteRemoval() {
    
    let addToFavorites = self.expectation(description: "addToFavorites")
    let networkRequest = self.expectation(description: "network request")
    
    unowned let favs = PKEFavoritesController.shared()
    favs.clearFavorites()
    
    XCTAssertFalse(favs.isFavorite(313), "Should not be favorite initially")
    
    if !favs.isFavorite(313) {
        NSLog("Adding 313 to favorites")
        favs.add(toFavorites: 313, withName: "Skatås")
    }
    
    let notification = self.expectation(forNotification: NSNotification.Name("didRemoveFavoriteNotification"), object: nil) { (notification) -> Bool in
        NSLog("Received notification: \(notification.name.rawValue)")

        return true
    }
    
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        NSLog("Verifying 313 is favorite")
        XCTAssertTrue(favs.isFavorite(313))
        addToFavorites.fulfill()
    }
    
    self.wait(for: [addToFavorites], timeout: 5)
    
    NSLog("Will trigger removal for 313")
    let _ = SkidsparAPI.fetchRecentReports(forSite: 313, session: SkidsparAPI.session()) { (reports) in
        NSLog("Network request completed")
        networkRequest.fulfill()
    }
    

    self.wait(for: [networkRequest, notification], timeout: 10)

    XCTAssertFalse(favs.isFavorite(313), "Favorite should be removed after a 404 error from server")
    
}

Answer 1

为了给出我的答案的上下文，这是建议更改时相关代码的样子:

- (NSArray *)favorites {
    @synchronized(internalFavorites) {
        if (!internalFavorites) {
            static dispatch_once_t onceToken;
            dispatch_once(&onceToken, ^{
                internalFavorites = [self.defaults objectForKey:k_key_favorites];
            });
            if (!internalFavorites) {
                internalFavorites = [NSArray array];
            }
        }
    }

    return internalFavorites;
}

我对 @synchronized(internalFavorites) 之后的检查 if (!internalFavorites) { 表示怀疑，因为这意味着期望 @synchronized 被传递 nil，即 results in a noop .

这意味着对 favorites 或 setFavorites 的多次调用可能会以有趣的方式发生，因为它们实际上不会同步。为 @sychronized 提供一个实际的同步对象对于线程安全至关重要。在 self 上同步很好，但是对于特定的类，您必须注意不要在 self 上同步太多东西，否则您将不可避免地产生不必要的阻塞。为 @sychronized 提供简单的 NSObject 是缩小保护范围的好方法。

以下是避免使用 self 作为锁的方法。

- (instancetype)init {
    static PKEFavoritesController *initedObject;
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        initedObject = [super init];
        self.lock = [NSObject new];
        self.defaults = [NSUserDefaults standardUserDefaults];
    });
    return initedObject;
}

+ (instancetype)sharedController {
    return [self new];
}

- (NSArray *)favorites {
    @synchronized(_lock) {
        if (!internalFavorites) {
            static dispatch_once_t onceToken;
            dispatch_once(&onceToken, ^{
                self->internalFavorites = [self.defaults objectForKey:k_key_favorites];
            });
            if (!internalFavorites) {
                internalFavorites = [NSArray array];
            }
        }
    }

    return internalFavorites;
}

关于测试运行之间的异常，在 NSUserDefaults 上调用 synchronize 肯定会有所帮助，因为更改默认值的调用是异步的，这意味着涉及其他线程。也有大约 3 层缓存，特别是为了运行测试的目的 synchronize 应该确保在 Xcode 拔掉测试运行的插头之前完全和干净地提交事情。文档非常突然地坚持认为这不是必要的调用，但如果确实没有必要，它就不会存在 :-)。在我的第一个 iOS 项目中，我们总是在每次默认值更改后调用 synchronize ......因此，我认为文档对 Apple 工程师来说更有吸引力。很高兴这种直觉对您有所帮助。