Swift中如何从主线程终止DispatchQueue启动的后台运行线程？

Great question! In Swift with GCD, you can’t directly force-terminate a background thread or task—GCD intentionally doesn’t expose APIs for this, since forced termination can cause resource leaks, corrupted data, or inconsistent app state. Instead, you need to implement cooperative cancellation: the background task checks periodically if it should stop, and the main thread signals that cancellation request.

Here are three practical, production-ready approaches you can use:

1. Use DispatchWorkItem (Recommended for GCD) #

DispatchWorkItem is a lightweight wrapper for your task logic that includes built-in cancellation support. It’s clean, integrates seamlessly with GCD, and is available since iOS 8.

Step 1: Define a property to hold the work item #

private var writeWorkItem: DispatchWorkItem?

Step 2: Launch the background task with the work item #

// Create the work item with your write operations
writeWorkItem = DispatchWorkItem { [weak self] in
    guard let self = self else { return }
    
    // Iterate over tasks to make cancellation checks straightforward
    let taskIds = [1, 2, 3, 4, 5]
    for id in taskIds {
        // Check if cancellation was requested BEFORE running each write
        guard !self.writeWorkItem!.isCancelled else {
            print("Write operation cancelled early")
            return
        }
        self.writeValue(tag: GlobalData.WRITE_DATA, data: getDataForWrite(id))
    }
    
    // Only run this if all tasks completed without cancellation
    DispatchQueue.main.async {
        print("done writing data")
    }
}

// Submit the work item to the background queue
DispatchQueue.global(qos: .background).async(execute: writeWorkItem!)

Step 3: Cancel from the main thread #

When you need to stop the task, call cancel() and nil out the reference to avoid retain cycles:

writeWorkItem?.cancel()
writeWorkItem = nil // Clean up resources

2. Use a Thread-Safe Boolean Flag (For Legacy Support) #

If you need to support older iOS versions or prefer a more manual approach, use a thread-safe boolean flag to signal cancellation.

Step 1: Define flag and thread-safe accessors #

import os.lock

private var isCancelled = false
private let cancellationLock = os_unfair_lock()

// Thread-safe method to trigger cancellation
func cancelWriteTasks() {
    os_unfair_lock_lock(&cancellationLock)
    isCancelled = true
    os_unfair_lock_unlock(&cancellationLock)
}

// Thread-safe method to check cancellation state
private func shouldCancel() -> Bool {
    os_unfair_lock_lock(&cancellationLock)
    let result = isCancelled
    os_unfair_lock_unlock(&cancellationLock)
    return result
}

Step 2: Update your background task to check the flag #

DispatchQueue.global(qos: .background).async { [weak self] in
    guard let self = self else { return }
    
    let taskIds = [1, 2, 3, 4, 5]
    for id in taskIds {
        if self.shouldCancel() {
            print("Write operation cancelled early")
            return
        }
        self.writeValue(tag: GlobalData.WRITE_DATA, data: getDataForWrite(id))
    }
    
    DispatchQueue.main.async {
        print("done writing data")
    }
}

Step 3: Trigger cancellation from the main thread #

cancelWriteTasks()

3. Use Task with async/await (iOS 15+, Swift Concurrency) #

If your app targets iOS 15 or later, Swift Concurrency’s Task is a modern, concise alternative that simplifies cancellation.

Step 1: Define a property to hold the task #

private var writeTask: Task<Void, Never>?

Step 2: Launch the async task #

writeTask = Task { [weak self] in
    guard let self = self else { return }
    
    for id in 1...5 {
        // Check if cancellation was requested (throws if cancelled)
        try? Task.checkCancellation()
        self.writeValue(tag: GlobalData.WRITE_DATA, data: getDataForWrite(id))
    }
    
    // Safely switch back to the main thread with MainActor
    await MainActor.run {
        print("done writing data")
    }
}

Step 3: Cancel from the main thread #

writeTask?.cancel()
writeTask = nil

Key Reminders #

• Cooperative cancellation is non-negotiable: Your background task must check the cancellation signal at logical points (like before each writeValue call). If writeValue itself is a long-running operation, add checks inside that function too.
• Avoid retain cycles: Always use [weak self] in background closures to prevent memory leaks.

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