Swift中ViewController释放后如何保证后台任务正常完成？

要满足你的需求——任务在ViewController销毁后仍能完成，同时不阻塞UI、不影响VC释放——核心是让任务的生命周期与ViewController完全解绑，避免两者之间的强引用绑定。以下是两种可靠的实现方式：

方案一：单例任务管理器（推荐用于需统一管理的多任务场景） #

创建一个独立的单例类来管理所有后台任务，由它持有任务的强引用，确保任务运行期间不会被销毁，任务完成后自动释放引用避免内存泄漏。

代码示例 #

import Foundation

class TaskManager {
    static let shared = TaskManager()
    private let queue = DispatchQueue(label: "com.yourapp.taskmanager")
    private var ongoingTasks: Set<String> = []
    
    private init() {} // 确保单例唯一
    
    func startBackgroundTask(withID taskID: String, task: @escaping () async throws -> Void) {
        queue.sync {
            // 避免重复启动同一ID的任务
            guard !ongoingTasks.contains(taskID) else { return }
            ongoingTasks.insert(taskID)
        }
        
        Task { [weak self] in
            do {
                try await task()
            } catch {
                print("Task \(taskID) failed: \(error.localizedDescription)")
            }
            
            // 任务完成后移除引用
            self?.queue.sync {
                self?.ongoingTasks.remove(taskID)
            }
        }
    }
}

// 在ViewController中调用
class TargetViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        TaskManager.shared.startBackgroundTask(withID: "UserInitiatedFlow") {
            // 你的并发+串行任务逻辑
            await withTaskGroup(of: Void.self) { group in
                // 并发任务1：异步服务请求
                group.addTask {
                    await ServiceLayer.shared.fetchDataFromServiceA()
                }
                // 并发任务2：另一个异步请求
                group.addTask {
                    await ServiceLayer.shared.fetchDataFromServiceB()
                }
            }
            
            // 串行任务：依赖前序并发任务完成
            await ServiceLayer.shared.processCombinedData()
        }
    }
}

// 独立的服务层（任务逻辑与VC完全解耦）
class ServiceLayer {
    static let shared = ServiceLayer()
    
    func fetchDataFromServiceA() async {
        // 模拟异步网络请求
        try? await Task.sleep(nanoseconds: 3_000_000_000)
    }
    
    func fetchDataFromServiceB() async {
        try? await Task.sleep(nanoseconds: 2_000_000_000)
    }
    
    func processCombinedData() async {
        try? await Task.sleep(nanoseconds: 1_000_000_000)
    }
}

方案优势 #

• 任务由TaskManager持有，与VC的生命周期完全无关，VC销毁后任务仍能正常执行
• 支持任务去重、统一错误处理和状态管理
• 任务完成后自动移除引用，无内存泄漏风险

方案二：顶层异步任务（适用于简单独立任务） #

如果任务不需要统一管理，可以直接在VC中启动顶层Swift Concurrency Task——这类任务由系统调度器持有强引用，只要任务在运行，即使VC被销毁，任务也会继续执行直到完成。

代码示例 #

class TargetViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 启动顶层Task，不捕获VC的强引用（因为任务不依赖VC）
        Task {
            do {
                await withTaskGroup(of: Void.self) { group in
                    group.addTask {
                        await ServiceLayer.shared.fetchDataFromServiceA()
                    }
                    group.addTask {
                        await ServiceLayer.shared.fetchDataFromServiceB()
                    }
                }
                await ServiceLayer.shared.processCombinedData()
            } catch {
                print("Task failed: \(error.localizedDescription)")
            }
        }
    }
}

关键注意点 #

• 绝对不要在任务中捕获VC的强引用（比如self），否则会导致VC无法销毁，造成内存泄漏
• 如果确实需要引用VC（你的场景不需要），必须使用[weak self]避免循环引用

对你疑问的解答 #

1. VC释放后，任务类实例是否会被销毁？
   如果你直接在VC中实例化任务类且仅由VC持有强引用，VC释放时任务类实例的引用计数会归零，导致任务被中断销毁。

2. 强引用任务类会不会阻止VC释放？
   如果任务类没有引用VC，VC释放时不会被阻止，但任务类会随之销毁；如果任务类强引用VC，则会形成循环引用，导致VC和任务类都无法释放，造成内存泄漏。

内容的提问来源于stack exchange，提问作者Ahmet Yılmaz