如何在另一个线程操作Core Data，修改数据后不持久化且保留原始数据？

当然可以实现！而且有几种非常贴合你需求的方案，我来给你拆解一下：

方案1：使用私有NSManagedObjectContext（最推荐） #

这是Core Data场景下处理临时修改最标准的方式——创建一个独立的私有上下文，所有修改都在这个上下文里进行，只要不调用save()，所有修改都会随着上下文销毁而消失，完全不影响原始数据。

// 假设你的计算结果类型是CalculationResult
func doSomething() -> CalculationResult {
    // 创建私有队列类型的上下文，父上下文关联到你的主上下文
    let privateContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
    privateContext.parent = CoreDataStack.shared.mainContext
    
    var finalResult: CalculationResult!
    
    // 必须在私有上下文的队列里执行操作，保证线程安全
    privateContext.performAndWait {
        // 在私有上下文里获取数据（注意fetch请求要绑定这个上下文）
        let fetchRequest: NSFetchRequest<YourEntity> = YourEntity.fetchRequest()
        guard let dataItems = try? privateContext.fetch(fetchRequest) else {
            fatalError("Failed to fetch data for calculation")
        }
        
        // 修改数据对象的属性用于计算
        for item in dataItems {
            // 比如修改某个数值属性来做中间计算
            item.temporaryCalculationValue = item.originalValue * 1.5
        }
        
        // 执行你的核心计算逻辑
        finalResult = calculateFinalValue(from: dataItems)
    }
    
    // 私有上下文会被自动销毁，所有未保存的修改都会被丢弃
    return finalResult
}

这个方案的核心优势：

• 完全遵循Core Data的线程安全规范
• 修改被隔离在私有上下文里，不会污染主上下文或持久化存储
• 可以直接使用托管对象的关联关系，无需额外复制数据

方案2：创建数据对象的副本（轻量场景适用） #

如果你的数据量不大，也可以绕开Core Data上下文限制，把托管对象的属性复制到普通Swift结构体里，修改副本完成计算：

// 先定义一个和Core Data实体对应的结构体
struct YourEntityCopy {
    let originalValue: Double // 保留原始值
    var tempValue: Double     // 用于临时修改的属性
}

func doSomething() -> CalculationResult {
    // 在主上下文获取原始数据（如果是后台线程，要切换到对应上下文执行）
    let fetchRequest: NSFetchRequest<YourEntity> = YourEntity.fetchRequest()
    guard let originalItems = try? CoreDataStack.shared.mainContext.fetch(fetchRequest) else {
        fatalError("Failed to fetch data")
    }
    
    // 把托管对象的属性复制到结构体中
    let copiedItems = originalItems.map {
        YourEntityCopy(originalValue: $0.originalValue, tempValue: $0.originalValue)
    }
    
    // 修改副本的属性进行计算
    var mutableCopies = copiedItems
    for index in mutableCopies.indices {
        mutableCopies[index].tempValue = mutableCopies[index].originalValue * 2
    }
    
    // 基于副本计算最终结果
    let result = calculateFinalValue(from: mutableCopies)
    
    // 原始托管对象完全未被修改，无需担心持久化问题
    return result
}

这个方案适合简单计算场景，好处是完全规避了Core Data的上下文和线程限制，操作的是值类型，线程安全性更高。

方案3：使用Core Data临时属性（适合复用托管对象场景） #

如果你的计算逻辑必须依赖托管对象本身，可以在Core Data模型里添加一个临时属性（Transient Attribute）：

• 打开Core Data模型编辑器，给实体新增一个属性，勾选「Transient」选项（表示该属性不会被持久化到数据库）

之后你就可以放心修改这个临时属性，完全不用担心会被保存：

func doSomething() -> CalculationResult {
    let privateContext = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
    privateContext.parent = CoreDataStack.shared.mainContext
    
    var finalResult: CalculationResult!
    
    privateContext.performAndWait {
        guard let dataItems = try? privateContext.fetch(YourEntity.fetchRequest()) else {
            fatalError("Failed to fetch data")
        }
        
        // 修改临时属性（这个属性不会被持久化）
        for item in dataItems {
            item.transientTempValue = item.originalValue * 3
        }
        
        finalResult = calculateFinalValue(from: dataItems)
    }
    
    return finalResult
}

关键注意事项 #

• 线程安全第一：Core Data托管对象不能跨线程访问，所有操作必须在对应上下文的队列里执行（用perform或performAndWait）
• 绝对不要调用save()：只要调用了上下文的save()，私有上下文的修改会推送给父上下文，最终可能同步到数据库，所以计算完成后一定要避免保存操作
• 原始数据读取：不管用哪个方案，只要不修改托管对象的非临时属性，直接访问就能拿到数据库里的原始值

内容的提问来源于stack exchange，提问作者Sonius