在多线程环境中使用CoreData

最新推荐文章于 2022-08-05 11:58:13 发布
转载 最新推荐文章于 2022-08-05 11:58:13 发布 · 513 阅读 · 0

本文介绍如何在多线程环境下无阻塞地使用CoreData进行数据操作，通过三层NSManagedObjectContext嵌套的方式，确保数据库操作不会阻塞主线程，同时保持数据的一致性和完整性。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

链接：http://www.iliunian.com/2896.html

上回书说道，其实CoreData学起来也没有很复杂，我们其实增删改查都和别的ORM大同小异。但是世界总是很复杂的，一根筋的去考虑问题很容易卡到蛋，默认情况下我们的代码都在Main Thread中执行，数据库操作一旦量多了，频繁了，势必会阻塞住主线程的其他操作，俗话说，卡住了。

这个世界天然是多线程的，所以我们操作数据也必须多线程。CoreData对多线程的支持比较奇怪（按照一般的思路来说），CoreData的NSPersistentStoreCoordinator和NSManagedObjectContext对象都是不能跨线程使用的，NSManagedObject也不行，有人想加锁不就完了。No，作为一个处女座是不能忍受这么丑陋的解决方案的。其实NSManagedObjectContext已经对跨线程提供了内置的支持，只不过方式比较特殊，需要脑洞大开才行。

在创建NSManagedObject的时候有个构造器参数initWithConcurrencyType就是解决的关键所在，这个参数是一个枚举，有三个可选值：

NSConfinementConcurrencyType (或者不加参数，默认就是这个)
NSMainQueueConcurrencyType (表示只会在主线程中执行)
NSPrivateQueueConcurrencyType (表示可以在子线程中执行)
那么究竟应该怎么使用才能无阻塞无痛呢？

经过参考： http://www.cocoanetics.com/2012/07/multi-context-coredata/ 这篇文章，我们使用三层 NSManagedObjectContext 嵌套的方式。

NSManagedObjectContext是可以基于其他的 NSManagedObjectContext的，通过 setParentContext 方法，可以设置另外一个 NSManagedObjectContext 为自己的父级，这个时候子级可以访问父级下所有的对象，而且子级 NSManagedObjectContext 的内容变化后，如果执行save方法，会自动的 merge 到父级 NSManagedObjectContext 中，也就是子级save后，变动会同步到父级 NSManagedObjectContext。当然这个时候父级也必须再save一次，如果父级没有父级了，那么就会直接向NSPersistentStoreCoordinator中写入，如果有就会接着向再上一层的父级冒泡……

那么这里如同参考的文章一样，通过三个级别的 NSManagedObjectContext， 一个负责在background更新NSPersistentStoreCoordinator。一个用在主线程，主要执行插入，修改和删除操作，一些小的查询也可以在这里同步执行，如果有大的查询，就起一个新的 NSPrivateQueueConcurrencyType 类型的 NSManagedObjectContext，然后放在后台去执行查询，查询完成后将结果返回主线程。

NSManagedObjectContext在后台线程执行是通过 performBlock 方法来实现的，在传入的匿名block中执行的代码就是在子线程中了，比如

[_bgObjectContext performBlock:^{
__block NSError *inner_error = nil;
[_bgObjectContext save:&inner_error];
}];

那么如果是查询的话，因为 NSManagedObject 也不能跨线程访问，所以在block里获取到的NSManagedObject对象只能将objectid传到主线程，主线程再通过 objectWithID 恢复对象的方法，如下面的示例：

+(void)one:(NSString*)predicate on:(ObjectResult)handler{
NSManagedObjectContext *ctx = [[mmDAO instance] createPrivateObjectContext];
[ctx performBlock:^{
NSFetchRequest *fetchRequest = [self makeRequest:ctx predicate:predicate orderby:nil offset:0 limit:1];
NSError* error = nil;
NSArray* results = [ctx executeFetchRequest:fetchRequest error:&error];
if (error) {
NSLog(@"error: %@", error);
[[mmDAO instance].mainObjectContext performBlock:^{
handler(@[], nil);
}];
}
if ([results count]<1) {
[[mmDAO instance].mainObjectContext performBlock:^{
handler(@[], nil);
}];
}
NSManagedObjectID *objId = ((NSManagedObject*)results[0]).objectID;
[[mmDAO instance].mainObjectContext performBlock:^{
handler([[mmDAO instance].mainObjectContext objectWithID:objId], nil);
}];
}];
}

最后我们将上述的要点结合起来，解决方案就呼之欲出了。

首先我们还是需要一个抽象存储和数据操作的核心

mmDAO.h
 
//
// mmDAO.h
// agent
//
// Created by LiMing on 14-6-24.
// Copyright (c) 2014年 Alexander. All rights reserved.
//
 
#import <Foundation/Foundation.h>
 
typedef void(^OperationResult)(NSError* error);
 
@interface mmDAO : NSObject
@property (readonly, strong, nonatomic) NSOperationQueue *queue;
@property (readonly ,strong, nonatomic) NSManagedObjectContext *bgObjectContext;
@property (readonly, strong, nonatomic) NSManagedObjectContext *mainObjectContext;
 
+(mmDAO*)instance;
-(void) setupEnvModel:(NSString *)model DbFile:(NSString*)filename;
- (NSManagedObjectContext *)createPrivateObjectContext;
-(NSError*)save:(OperationResult)handler;
 
@end
mmDAO.m
 
//
// mmDAO.m
// agent
//
// Created by LiMing on 14-6-24.
// Copyright (c) 2014年 Alexander. All rights reserved.
//
 
#import "mmDAO.h"
#import "mmAppDelegate.h"
 
static mmDAO *onlyInstance;
 
@interface mmDAO ()
@property (nonatomic, copy)NSString *modelName;
@property (nonatomic, copy)NSString *dbFileName;
@end
 
@implementation mmDAO
+(mmDAO*)instance{
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
onlyInstance = [[mmDAO alloc] init];
});
return onlyInstance;
}
 
- (instancetype)init
{
self = [super init];
if (self) {
}
return self;
}
 
-(void) setupEnvModel:(NSString *)model DbFile:(NSString*)filename{
_modelName = model;
_dbFileName = filename;
[self initCoreDataStack];
}
 
- (void)initCoreDataStack
{
NSPersistentStoreCoordinator *coordinator = [self persistentStoreCoordinator];
if (coordinator != nil) {
_bgObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
[_bgObjectContext setPersistentStoreCoordinator:coordinator];
 
_mainObjectContext = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSMainQueueConcurrencyType];
[_mainObjectContext setParentContext:_bgObjectContext];
}
 
}
 
- (NSManagedObjectContext *)createPrivateObjectContext
{
NSManagedObjectContext *ctx = [[NSManagedObjectContext alloc] initWithConcurrencyType:NSPrivateQueueConcurrencyType];
[ctx setParentContext:_mainObjectContext];
 
return ctx;
}
 
- (NSManagedObjectModel *)managedObjectModel
{
NSManagedObjectModel *managedObjectModel;
NSURL *modelURL = [[NSBundle mainBundle] URLForResource:_modelName withExtension:@"momd"];
managedObjectModel = [[NSManagedObjectModel alloc] initWithContentsOfURL:modelURL];
return managedObjectModel;
}
 
- (NSPersistentStoreCoordinator *)persistentStoreCoordinator
{
NSPersistentStoreCoordinator *persistentStoreCoordinator = nil;
NSURL *storeURL = [[self applicationDocumentsDirectory] URLByAppendingPathComponent:_dbFileName];
 
NSError *error = nil;
persistentStoreCoordinator = [[NSPersistentStoreCoordinator alloc] initWithManagedObjectModel:[self managedObjectModel]];
if (![persistentStoreCoordinator addPersistentStoreWithType:NSSQLiteStoreType configuration:nil URL:storeURL options:nil error:&error]) {
NSLog(@"Unresolved error %@, %@", error, [error userInfo]);
abort();
}
return persistentStoreCoordinator;
}
 
- (NSURL *)applicationDocumentsDirectory
{
return [[[NSFileManager defaultManager] URLsForDirectory:NSDocumentDirectory inDomains:NSUserDomainMask] lastObject];
}
 
-(NSError*)save:(OperationResult)handler{
NSError *error;
if ([_mainObjectContext hasChanges]) {
[_mainObjectContext save:&error];
[_bgObjectContext performBlock:^{
__block NSError *inner_error = nil;
[_bgObjectContext save:&inner_error];
if (handler){
//handler(error);
//这里需要返回主线程，不然在回调里操作界面会出错
[_mainObjectContext performBlock:^{
handler(error);
}];
}
}];
}
return error;
}
 
@end

然后我们扩展 NSManagedObject，把操作注入到类里，这样子有个好处是可以自动获取类名，然后就不用子级写字符串的类名了。

NSManagedObject+helper.h
 
//
//  NSManagedObject+helper.h
//  agent
//
//  Created by LiMing on 14-6-24.
//  Copyright (c) 2014年 bangban. All rights reserved.
//
 
typedef void(^ListResult)(NSArray* result, NSError *error);
typedef void(^ObjectResult)(id result, NSError *error);
 
#import <CoreData/CoreData.h>
#import "mmDAO.h"
 
@interface NSManagedObject (helper)
 
+(id)createNew;
 
+(NSError*)save:(OperationResult)handler;
 
+(NSArray*)filter:(NSString *)predicate orderby:(NSArray *)orders offset:(int)offset limit:(int)limit;
 
+(void)filter:(NSString *)predicate orderby:(NSArray *)orders offset:(int)offset limit:(int)limit on:(ListResult)handler;
 
+(id)one:(NSString*)predicate;
 
+(void)one:(NSString*)predicate on:(ObjectResult)handler;
 
+(void)delobject:(id)object;
@end
NSManagedObject+helper.m
 
//
//  NSManagedObject+helper.m
//  agent
//
//  Created by LiMing on 14-6-24.
//  Copyright (c) 2014年 bangban. All rights reserved.
//
 
#import "NSManagedObject+helper.h"
 
@implementation NSManagedObject (helper)
+(id)createNew{
    NSString *className = [NSString stringWithUTF8String:object_getClassName(self)];
    return [NSEntityDescription insertNewObjectForEntityForName:className inManagedObjectContext:[mmDAO instance].mainObjectContext];
}
 
+(NSError*)save:(OperationResult)handler{
    return [[mmDAO instance] save:handler];
}
 
+(NSArray*)filter:(NSString *)predicate orderby:(NSArray *)orders offset:(int)offset limit:(int)limit{
 
    NSManagedObjectContext *ctx = [mmDAO instance].mainObjectContext;
    NSFetchRequest *fetchRequest = [self makeRequest:ctx predicate:predicate orderby:orders offset:offset limit:limit];
 
    NSError* error = nil;
    NSArray* results = [ctx executeFetchRequest:fetchRequest error:&error];
    if (error) {
        NSLog(@"error: %@", error);
        return @[];
    }
    return results;
}
 
+(NSFetchRequest*)makeRequest:(NSManagedObjectContext*)ctx predicate:(NSString*)predicate orderby:(NSArray*)orders offset:(int)offset limit:(int)limit{
    NSString *className = [NSString stringWithUTF8String:object_getClassName(self)];
    NSFetchRequest *fetchRequest = [[NSFetchRequest alloc] init];
    [fetchRequest setEntity:[NSEntityDescription entityForName:className inManagedObjectContext:ctx]];
    [fetchRequest setPredicate:[NSPredicate predicateWithFormat:predicate]];
    NSMutableArray *orderArray = [[NSMutableArray alloc] init];
    if (orders!=nil) {
        for (NSString *order in orders) {
            NSSortDescriptor *orderDesc = nil;
            if ([[order substringToIndex:1] isEqualToString:@"-"]) {
                orderDesc = [[NSSortDescriptor alloc] initWithKey:[order substringFromIndex:1]
                                                        ascending:NO];
            }else{
                orderDesc = [[NSSortDescriptor alloc] initWithKey:order
                                                        ascending:YES];
            }
        }
        [fetchRequest setSortDescriptors:orderArray];
    }
    if (offset>0) {
        [fetchRequest setFetchOffset:offset];
    }
    if (limit>0) {
        [fetchRequest setFetchLimit:limit];
    }
    return fetchRequest;
}
 
+(void)filter:(NSString *)predicate orderby:(NSArray *)orders offset:(int)offset limit:(int)limit on:(ListResult)handler{
 
    NSManagedObjectContext *ctx = [[mmDAO instance] createPrivateObjectContext];
    [ctx performBlock:^{
        NSFetchRequest *fetchRequest = [self makeRequest:ctx predicate:predicate orderby:orders offset:offset limit:limit];
        NSError* error = nil;
        NSArray* results = [ctx executeFetchRequest:fetchRequest error:&error];
        if (error) {
            NSLog(@"error: %@", error);
            [[mmDAO instance].mainObjectContext performBlock:^{
                handler(@[], nil);
            }];
        }
        if ([results count]<1) {
            [[mmDAO instance].mainObjectContext performBlock:^{
                handler(@[], nil);
            }];
        }
        NSMutableArray *result_ids = [[NSMutableArray alloc] init];
        for (NSManagedObject *item  in results) {
            NSLog(@"id=%@", item.objectID);
            [result_ids addObject:item.objectID];
        }
        [[mmDAO instance].mainObjectContext performBlock:^{
            NSMutableArray *final_results = [[NSMutableArray alloc] init];
            for (NSManagedObjectID *oid in result_ids) {
                [final_results addObject:[[mmDAO instance].mainObjectContext objectWithID:oid]];
            }
            handler(final_results, nil);
        }];
    }];
}
 
+(id)one:(NSString*)predicate{
    NSManagedObjectContext *ctx = [mmDAO instance].mainObjectContext;
    NSFetchRequest *fetchRequest = [self makeRequest:ctx predicate:predicate orderby:nil offset:0 limit:1];
    NSError* error = nil;
    NSArray* results = [ctx executeFetchRequest:fetchRequest error:&error];
    if ([results count]!=1) {
        raise(1);
    }
    return results[0];
}
 
+(void)one:(NSString*)predicate on:(ObjectResult)handler{
    NSManagedObjectContext *ctx = [[mmDAO instance] createPrivateObjectContext];
    [ctx performBlock:^{
        NSFetchRequest *fetchRequest = [self makeRequest:ctx predicate:predicate orderby:nil offset:0 limit:1];
        NSError* error = nil;
        NSArray* results = [ctx executeFetchRequest:fetchRequest error:&error];
        if (error) {
            NSLog(@"error: %@", error);
            [[mmDAO instance].mainObjectContext performBlock:^{
                handler(@[], nil);
            }];
        }
        if ([results count]<1) {
            [[mmDAO instance].mainObjectContext performBlock:^{
                handler(@[], nil);
            }];
        }
        NSManagedObjectID *objId = ((NSManagedObject*)results[0]).objectID;
        [[mmDAO instance].mainObjectContext performBlock:^{
            handler([[mmDAO instance].mainObjectContext objectWithID:objId], nil);
        }];
    }];
}
 
+(void)delobject:(id)object{
    //[[mmDAO instance].mainObjectContext delete:object];
    //这里方法名写错了
    [[mmDAO instance].mainObjectContext deleteObject:object];
}
 
@end

本文内容已经打包放在了github，有兴趣的可以fork下来直接用 https://github.com/ipconfiger/asyncCoreDataWrapper

另，文中代码有两处错误，已经加上了注释，提前看了的同学记得以github为准。

from:http://liming.me/2014/06/25/noblocking-coredata-in-multithread/


多线程的 Core Data
DamianSheldon的博客
11-30 212
原始 Octopress 博客 平常在项目中没有使用过 Core Data, 因为我觉得它的学习曲线还挺陡峭，整个框架给人的感觉很复杂和笨重，因此一直没有使用它。但是看到喵神这份上级向的十个 iOS 开发面试题中和这份百度面试题中都有涉及到 Core Data 的内容，我想还是有必要好好研究一下它，毕竟它是 Apple 官方的持久化方案，我们可以取其精华，弃其糟粕，另一方面未来我们也可能因为各种原...
QGLCoreDataPlugin:使用多线程管理CoreData数据
06-29
CoreData并不直接支持多线程，因此在多线程环境中使用时需要特别注意线程安全。QGLCoreDataPlugin通过创建和管理独立的ManagedObjectContext（MOC）实例来实现这一点。每个线程拥有自己的MOC，它们之间相互隔离，...
认识CoreData-多线程
weixin_33951761的博客
07-29 180
  CoreData使用相关的技术点已经讲差不多了，我所掌握的也就这么多了.... 在本篇文章中主要讲CoreData的多线程，其中会包括并发队列类型、线程安全等技术点。我对多线程的理解可能不是太透彻，文章中出现的问题还请各位指出。在之后公司项目使用CoreData的过程中，我会将其中遇到的多线程相关的问题更新到文章中。   在文章的最后，会根据我对CoreData多线程的学习，以及在工...
多线程操作数据库 (CoreData)
jmulxg的专栏
11-16 7689
1： 主线程修改了数据库的某一条记录，但是子线程没有发生变化，反过来一样的问题。这种情况一般是发生在app有多个NSManagedObjectContext，两个线程分别对其进行了读写操作。 2： 有时候程序会莫名其妙的crash掉，这个有很多原因：           a： 有时候是因为两个线程同时读写数据库中的同一条记录。           b： 有时候根本找不到是哪里的原因。
CoreData多线程安全
热门推荐
chen505358119的专栏
07-16 2万+
CoreData中的NSManagedObjectContext在多线程中不安全,如果想要多线程访问CoreData的话，最好的方法是一个线程一个NSManagedObjectContext, ,每个NSManagedObjectContext对象实例都可以使用同一个NSPersistentStoreCoordinator实例，这个实例可以很安全的顺序访问永久存储，这是因为NSManagedO
Core Data: 多线程大量数据同步
shancheli的博客
11-06 695
前言：本文是我几个月前的这篇《iOS 面试基础题目》 其中的一个问题的回答，这几天整理博客，更新内容，自觉有能力回答这个问题了。这篇单独拿出来首先是因为这个问题很不错，值得单独写一篇；其次为了便于检索，因为简书目前不支持标签，只能通过文集来分类，有点不方便，折腾个优美的基于 Github 的博客又嫌麻烦，暂时还是在这里写吧，等有精力了迁移；最后是因为这个回答写得太长了，原本打算写个大纲型的，但
iOS5多线程环境下CoreData的高效运用
但在iOS5中，Apple引入了一些新的功能和方法，使得在多线程环境中使用CoreData变得更加容易和安全。 首先，iOS5中的CoreData提供了新的并发API，如`performBlock:`和`performBlockAndWait:`方法。这些方法可以让...
iPhone 多线程 CoreData使用源代码
10-12
因此，理解如何在多线程环境下使用CoreData至关重要。 首先，我们来看如何创建多线程。iOS提供了多种多线程技术，包括NSThread、NSOperationQueue、GCD（Grand Central Dispatch）等。其中，GCD因其高效和易用性而...
多线程环境下轻松操作CoreData的封装工具
因此，封装Core Data以支持多线程操作，可以帮助开发者更方便地在多线程环境下使用Core Data，提高开发效率和应用程序的性能。 4. asyncCoreDataWrapper的介绍: asyncCoreDataWrapper是一个开源的IOS项目，它对Core...
PCCoredataDemo:一个多线程coredata封装库介绍
PCCoredataDemo库的出现，就是为了解决coredata在多线程操作中可能出现的问题，提供一个简洁、安全的封装层，让开发者可以更加方便地在多线程环境中使用coredata进行数据持久化操作。 针对多线程的coredata封装，...
Core Data多线程大量数据同步
01-10
Core Data多线程大量数据同步，ios开发
iOS Coredata安全之多线程
say__ever的专栏
09-25 2794
今天去一家公司面试，被问到coredata是怎么处理
Coredata多线程
mainjun的专栏
12-01 379
CoreData中的NSManagedObjectContext在多线程中不安全,如果想要多线程访问CoreData的话，最好的方法是一个线程一个NSManagedObjectContext, ,每个NSManagedObjectContext对象实例都可以使用同一个NSPersistentStoreCoordinator实例，这个实例可以很安全的顺序访问永久存储，这是因为NSManagedOb
Core Data 多线程设计
VictorZhang
08-05 262
CoreData 多线程记录
iOS开发中一些常见的并行处理(转)
weixin_30765475的博客
12-11 182
本文主要探讨一些常用多任务的最佳实践。包括Core Data的多线程访问，UI的并行绘制，异步网络请求以及一些在运行态内存吃紧的情况下处理大文件的方案等。

其实编写异步处理的程序有很多坑！所以，本文所涉及的样例都尽量采用简洁直观的处理方式。因为越是简单的逻辑结构，越能彰显代码的脉络清晰，越易于理解。打个比方，如果在程序中使用多层次的嵌套回调，基本上这个它会有很大的重构空间。 Operat...
CoreData 多线程处理大量数据同步时的操作
Linlei的专栏
06-01 5282
CoreData是CoCoa中处理数据绑定数据的关键特性，提供完整的对象持久化存储方案。如果你使用sqlite3厌倦了敲打sql语句，CoreData正解决了你这烦恼。sqlite3是CoreData处理的数据类型之一，当你将CoreData和sqlite的结合起来使用的话，你将能开发出强大的数据库应用。 CoreData与多线程 为了在查询数据的时候不让界面停滞，使用多线程是不可避免
（转载）Multi-Context CoreData 之多线程环境中使用CoreData
VictorZhang
06-13 328
CoreData 多线程使用
swift支持多线程操作数据库类库-CoreDataManager
walkerwqp的博客
06-13 1018
swift支持多线程操作数据库类库-CoreDataManager
CoreData 多线程传值的问题
jinzhongjunqianyan的专栏
10-24 578
CoreData中的NSManagedObjectContext在多线程中是不安全的，在多线程中使用CoreData时，你有可能会得到类似data: 的错误信息，这本来是CoreData的一种懒加载机制，当你需要使用某条数据的时候，coredata才帮你加载对应的数据。但是用在多线程中的使用过程中，你可能加载不出对应的属性值，所以如果想要多线程访问CoreData的话，最好的方法是一个线程一个NS
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值