Swift iOS中后台线程运行函数并实现重复调用时取消旧任务

原代码问题分析 #

你的代码核心问题出在这几点：

• workItem的读写没有线程安全保障，UI线程和后台队列可能同时操作它，导致状态混乱
• 取消旧任务和提交新任务的逻辑没有同步，串行队列的barrier用法无效，无法确保旧任务取消完成后再启动新任务
• 手动管理DispatchWorkItem的取消状态容易出错，递归场景下的检查逻辑不够严谨

基于Swift结构化并发的最优实现 #

Swift 5.5引入的结构化并发（Task）是处理这类场景的最佳方案，配合Actor可以轻松实现线程安全的任务管理，彻底解决重入问题：

import Foundation

actor TaskManager {
    private var ongoingTask: Task<Void, Never>?
    
    func startLongWork() async {
        // 立即取消正在运行的旧任务
        ongoingTask?.cancel()
        // 创建新任务并保存引用
        ongoingTask = Task { [weak self] in
            await self?.longWork()
            // 任务未被取消时清空引用，避免内存冗余
            guard !Task.isCancelled else { return }
            self?.ongoingTask = nil
        }
    }
    
    private func longWork() async {
        func recursiveFunction() async {
            // 结构化并发中直接检查当前任务的取消状态，无需手动管理外部变量
            guard !Task.isCancelled else { return }
            // 替换为你的递归计算逻辑
            try? await Task.sleep(nanoseconds: 100_000_000) // 模拟耗时操作
            await recursiveFunction()
        }
        
        await recursiveFunction()
        
        // 任务未被取消才执行UI更新
        guard !Task.isCancelled else { return }
        
        // 安全回到主线程更新UI
        await MainActor.run {
            // 这里写你的UI更新代码
            print("UI更新完成")
        }
    }
}

// 业务类使用示例
class SomeClass {
    private let taskManager = TaskManager()
    
    func doLongWork() {
        // 从UI线程调用时，用Task后台启动异步逻辑
        Task {
            await taskManager.startLongWork()
        }
    }
}

关键改进说明 #

• Actor线程安全：TaskManager作为Actor，确保ongoingTask的所有读写操作都在串行执行环境中，彻底避免多线程竞争
• 原生取消机制：直接使用Task.isCancelled检查取消状态，比手动管理DispatchWorkItem更可靠，递归场景下也能轻松嵌入检查逻辑
• 严格任务串行：新任务创建前必然先取消旧任务，保证同一时间只有一个任务在运行，完全杜绝重入问题
• UI安全更新：用MainActor.run自动切换到主线程更新UI，符合iOS的UI操作规范

兼容旧版本的GCD替代方案 #

如果需要兼容Swift 5.5以下版本，也可以用GCD实现，但必须确保所有workItem的操作都在串行队列中同步执行：

class SomeClass {
    private var workItem: DispatchWorkItem?
    private let serialQueue = DispatchQueue(label: "com.example.taskQueue")
    
    func doLongWork() {
        serialQueue.async { [weak self] in
            // 先取消旧任务
            self?.workItem?.cancel()
            // 创建并启动新任务
            let newWorkItem = DispatchWorkItem { [weak self] in
                self?.longWork()
            }
            self?.workItem = newWorkItem
            newWorkItem.perform()
        }
    }
    
    private func longWork() {
        func recursiveFunction() {
            guard !(workItem?.isCancelled ?? false) else { return }
            // 替换为你的递归计算逻辑
            Thread.sleep(forTimeInterval: 0.1) // 模拟耗时操作
            recursiveFunction()
        }
        
        recursiveFunction()
        
        guard !(workItem?.isCancelled ?? false) else { return }
        
        DispatchQueue.main.async {
            // 这里写你的UI更新代码
            print("UI更新完成")
        }
        
        // 任务完成后清空workItem（需在串行队列操作）
        serialQueue.async { [weak self] in
            self?.workItem = nil
        }
    }
}

这个GCD版本把所有workItem的管理操作都放到串行队列中执行，确保取消旧任务、创建新任务的顺序绝对不会混乱，解决了原代码中的同步问题。

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