CoreData崩溃排查：枚举时集合被修改及关联关系问题

崩溃根源 #

1. 线程安全违规：CoreData上下文（如viewContext）并非线程安全，若你在非主线程执行持久化操作，或在主线程进行大量CoreData操作，会触发集合并发修改、内存访问错误。
2. 上下文不一致：fetchSingle硬编码使用全局viewContext，而非传入的上下文；且所有操作未强制在上下文对应的线程执行，导致跨线程访问风险。
3. 关联关系操作不规范：手动维护sectionID、categoryID外键，未利用CoreData自带的反向关联关系，导致关系维护混乱；addToSongs这类自动生成的方法在更新现有实体时，易与原有集合产生冲突。
4. 嵌套循环低效且易冲突：三层嵌套循环每次都触发CoreData查询，频繁操作上下文大幅提升了线程冲突概率。

修复步骤 #

1. 修正上下文使用，保证线程安全 #

viewContext仅能在主线程操作，后台处理必须创建私有上下文，且所有CoreData操作需包裹在上下文的线程执行方法中。

修改fetchSingle方法

public func fetchSingle<T: NSManagedObject>(
  _ entityClass: T.Type,
  in context: NSManagedObjectContext,
  sortBy sortDescriptors: [NSSortDescriptor]? = nil,
  predicate: NSPredicate? = nil
) -> T? {
  let entityName = String(describing: entityClass)
  let fetchRequest = NSFetchRequest<T>(entityName: entityName)

  fetchRequest.sortDescriptors = sortDescriptors
  fetchRequest.predicate = predicate
  fetchRequest.fetchLimit = 1 

  var result: T?
  // 强制在上下文线程执行查询
  context.performAndWait {
    do {
      let items = try context.fetch(fetchRequest)
      result = items.first
    } catch {
      debugPrint(error.localizedDescription)
    }
  }
  return result
}

修改SongEntity的fetchOrCreate（Section、Category同理实现）

public extension SongEntity {
    static func fetchOrCreate(for songID: String, in context: NSManagedObjectContext) -> SongEntity {
        var entity: SongEntity?
        context.performAndWait {
            // 使用传入的上下文查询
            entity = PersistenceController.shared.fetchSingle(SongEntity.self, in: context, predicate: SongEntity.bySongID(songID))
            if entity == nil {
                entity = SongEntity(context: context)
                entity?.identifier = songID // 提前设置ID，避免重复创建
            }
        }
        return entity!
    }

    static func bySongID(_ songID: String) -> NSPredicate {
        NSPredicate(format: "identifier == %@", songID)
    }
}

2. 利用CoreData关联关系替代手动外键 #

在Data Model中配置正确的反向关联：

• Section ↔ Category：Section设categories（一对多），Category设section（多对一）
• Category ↔ SongEntity：Category设songs（一对多），SongEntity设category（多对一）

修改关系赋值逻辑，不再手动维护外键：

// 关联Category到Section
existingCategory.section = sectionEntity
// 关联Song到Category
existingSong.category = existingCategory

3. 重构循环逻辑，减少嵌套与查询次数 #

先将JSON数据分组，避免三层嵌套循环，提升效率并降低冲突概率：

// 预分组：按sectionID分类categories
let categoriesBySectionID = Dictionary(grouping: songsData.sectionCategories, by: { $0.sectionID })
// 按categoryID分类songs
let songsByCategoryID = Dictionary(grouping: songsData.songs, by: { $0.categoryID })

// 处理每个Section
for section in songsData.sections {
    context.performAndWait {
        let sectionEntity = Section.fetchOrCreate(for: section.identifier, in: context)
        sectionEntity.title = section.title
        
        // 获取当前Section对应的分类
        guard let sectionCategories = categoriesBySectionID[section.identifier] else {
            sectionEntity.categories = []
            return
        }
        
        var categoryEntities: [Category] = []
        for category in sectionCategories {
            let categoryEntity = Category.fetchOrCreate(for: category.identifier, in: context)
            categoryEntity.title = category.title
            categoryEntity.section = sectionEntity
            
            // 获取当前分类对应的歌曲
            guard let categorySongs = songsByCategoryID[category.identifier] else {
                categoryEntity.songs = []
                categoryEntities.append(categoryEntity)
                continue
            }
            
            var songEntities: [SongEntity] = []
            for song in categorySongs {
                let songEntity = SongEntity.fetchOrCreate(for: song.identifier, in: context)
                songEntity.title = song.title
                songEntity.category = categoryEntity
                songEntities.append(songEntity)
            }
            categoryEntity.songs = NSOrderedSet(array: songEntities)
            categoryEntities.append(categoryEntity)
        }
        sectionEntity.categories = NSOrderedSet(array: categoryEntities)
    }
}

// 保存上下文
do {
    try context.save()
} catch {
    debugPrint("保存失败：\(error.localizedDescription)")
}

4. 规避集合枚举时突变 #

崩溃提示的集合并发修改，本质是线程安全问题。通过performAndWait强制所有操作在上下文的同一线程执行，即可避免此类冲突。

额外注意事项 #

• 所有CoreData操作必须通过perform/performAndWait包裹，确保在上下文对应的线程执行。
• 跨线程传递CoreData对象时，不要直接传递实例，应传递objectID，再在目标上下文用context.object(with: objectID)获取实例。
• 批量后台操作建议使用私有上下文，处理完成后保存并合并到viewContext。

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