如何在Managed Object Context中处理大量实体并按需保存且支持回滚？

用户需要在应用中支持创建1万至10万个Song实体并添加到播放列表，当前存在两个核心问题：

• 无法使用NSBatchInsertRequest，因为该操作会直接将数据持久化到磁盘，无法支持用户点击Cancel按钮回滚到播放列表的初始状态（比如原播放列表仅1首歌，添加1万首后取消，需恢复到1首歌的状态）
• 当前直接在主队列的Managed Object Context（MOC）中循环创建实体，导致应用冻结5-10秒，内存占用超过1GB

用户提供的数据模型和当前实现代码如下：

extension Playlist {

    @nonobjc public class func fetchRequest() -> NSFetchRequest<Playlist> {
        return NSFetchRequest<Playlist>(entityName: "Playlist")
    }

    @NSManaged public var name: String?
    @NSManaged public var id: UUID?

    var wrappedName: String {
        name ?? "Unknown Playlist"
    }
    
    var wrappedId: UUID {
        id ?? UUID()
    }
}

extension Song {

    @nonobjc public class func fetchRequest() -> NSFetchRequest<Song> {
        return NSFetchRequest<Song>(entityName: "Song")
    }

    @NSManaged public var name: String?
    @NSManaged public var fileExtension: String?
    @NSManaged public var artist: String?
    @NSManaged public var playlistId: UUID? //The playlist the song belongs to
    @NSManaged public var playlistIndex: Int64 //The index in which the song is at in a playlist

    var wrappedName: String {
        name ?? "Unknown Song"
    }
    
    var wrappedFileExtension: String {
        fileExtension ?? "Unknown File Extension"
    }
    
    var wrappedArtist: String {
        artist ?? "Unknown Artist"
    }
    
    var wrappedPlaylistId: UUID {
        playlistId ?? UUID()
    }
}

func savePlaylist(for playlistId: UUID) {
//moc is the main queue's managed object context

                        for i in 0...100000 {
                            let song = Song(context: moc)
                            song.name = "Song" + " \(i)"
                            song.fileExtension = "mp3"
                            song.artist = "Some artist"
                            song.playlistId = playlistId
                        }
                        
                        try? moc.save()
}

1. 用私有上下文+分批处理实现可回滚的批量创建 #

主队列卡顿的核心是所有操作都在主线程执行，阻塞UI。改用私有上下文在后台创建实体，既能避免卡顿，又能保留回滚能力：

• 创建私有队列类型的MOC，关联主上下文的持久化存储协调器
• 在私有MOC中分批创建Song实体（比如每1000个一批），每批创建完成后调用privateMOC.save()（仅保存到内存，未写入磁盘），然后重置上下文释放内存
• 用户确认保存时，将私有MOC的更改合并到主MOC再持久化；用户取消时直接销毁私有MOC，主上下文不受任何影响

示例代码：

func createSongsForPlaylist(playlistId: UUID, completion: @escaping (Bool) -> Void) {
    // 创建私有队列上下文
    let privateMOC = NSManagedObjectContext(concurrencyType: .privateQueueConcurrencyType)
    privateMOC.persistentStoreCoordinator = moc.persistentStoreCoordinator
    
    privateMOC.perform { [weak self] in
        guard let self = self else { return }
        let batchSize = 1000
        let totalSongs = 100000
        
        // 分批创建实体
        for batch in 0..<(totalSongs / batchSize) {
            let startIndex = batch * batchSize
            let endIndex = startIndex + batchSize
            
            for i in startIndex..<endIndex {
                let song = Song(context: privateMOC)
                song.name = "Song \(i)"
                song.fileExtension = "mp3"
                song.artist = "Some artist"
                song.playlistId = playlistId
                song.playlistIndex = Int64(i)
            }
            
            // 保存到私有上下文（仅内存），重置释放内存
            do {
                try privateMOC.save()
                privateMOC.reset()
            } catch {
                print("Batch save failed: \(error)")
                completion(false)
                return
            }
        }
        
        // 处理剩余不足一批的歌曲
        let remaining = totalSongs % batchSize
        if remaining > 0 {
            let startIndex = totalSongs - remaining
            for i in startIndex..<totalSongs {
                let song = Song(context: privateMOC)
                song.name = "Song \(i)"
                song.fileExtension = "mp3"
                song.artist = "Some artist"
                song.playlistId = playlistId
                song.playlistIndex = Int64(i)
            }
            do {
                try privateMOC.save()
            } catch {
                print("Remaining batch save failed: \(error)")
                completion(false)
                return
            }
        }
        
        // 用户确认后合并到主上下文
        self.moc.perform {
            do {
                try self.moc.save()
                completion(true)
            } catch {
                print("Main context save failed: \(error)")
                completion(false)
            }
        }
    }
}

// 调用示例：
// 用户点击确认时执行
createSongsForPlaylist(playlistId: targetPlaylistId) { success in
    if success {
        // 更新UI提示保存成功
    } else {
        // 提示保存失败
    }
}

// 用户点击取消时，直接丢弃privateMOC即可，主上下文状态不变

2. 优化数据模型减少内存占用 #

• 去掉Song中不必要的包装属性（wrappedName等），直接在使用时做nil处理，避免每个实体持有额外的计算属性引用
• 将playlistId改为与Playlist的关联关系（Relationship），Core Data的关系管理更高效，还能避免手动维护UUID一致性的问题，减少重复UUID字符串的内存占用

修改后的Song实体示例：

extension Song {
    // 替换原playlistId属性
    @NSManaged public var playlist: Playlist?
    // ...其他属性
}

// 创建Song时直接关联Playlist对象
if let playlist = fetchPlaylistById(playlistId, context: privateMOC) {
    song.playlist = playlist
}

3. 临时预览模式：避免提前创建所有实体 #

如果用户只是预览添加后的播放列表，不需要立即创建Core Data实体：

• 先在内存中维护一个临时数组，仅存储歌曲的必要字段（name、artist等），UI直接展示这个数组
• 用户确认保存后，再通过私有上下文批量创建并持久化；用户取消则直接丢弃数组，内存占用极低

4. 批量操作期间禁用自动合并更改 #

主上下文默认会自动合并私有上下文的更改，批量创建期间临时禁用，避免频繁的UI更新和内存消耗：

// 批量操作开始前禁用
moc.automaticallyMergesChangesFromParent = false

// 批量操作完成后恢复
moc.automaticallyMergesChangesFromParent = true

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