Swift Task.sleep timeout race condition in iOS 15 and iOS 16

Direct Answer

Recommended patterns: Use a TaskGroup with two children (the operation and a sleep task) on iOS 15; on iOS 16+ add withTaskCancellationHandler to register a synchronous cancel action that runs atomically with cancellation delivery.

Apple's plans: No public Swift Evolution proposal or WWDC session through 2024 announces a built-in Task.withTimeout or similar atomic timeout primitive. Apple engineers have indicated the structured-concurrency primitives (TaskGroup, cancellation handlers) are the intended building blocks.

Why the Race Window Exists

After try await Task.sleep(...) returns, the task resumes at the next line. A cancellation delivered during that gap is only observed at the next explicit Task.checkCancellation() or suspension point, allowing extra work to proceed past the deadline.

iOS 15 Pattern (Swift 5.5)

func withTimeout<T>(_ duration: UInt64, operation: @escaping () async throws -> T) async throws -> T {
    try await withThrowingTaskGroup(of: T.self) { group in
        group.addTask { try await operation() }
        group.addTask {
            try await Task.sleep(nanoseconds: duration)
            throw CancellationError()
        }
        guard let result = try await group.next() else { throw CancellationError() }
        group.cancelAll()
        return result
    }
}

The group cancels all children on first completion, bounding extra work to at most one iteration of a looping child.

iOS 16+ Pattern (Swift 5.7+)

func withTimeout<T>(_ duration: Duration, operation: @escaping () async throws -> T) async throws -> T {
    try await withTaskCancellationHandler {
        try await withThrowingTaskGroup(of: T.self) { group in
            group.addTask { try await operation() }
            group.addTask {
                try await Task.sleep(for: duration)
                throw CancellationError()
            }
            guard let result = try await group.next() else { throw CancellationError() }
            group.cancelAll()
            return result
        }
    } onCancel: {
        // Synchronous cancel action (e.g., close stream, set atomic flag)
        // Must not await or block
    }
}

withTaskCancellationHandler runs its onCancel closure atomically with cancellation delivery, narrowing the window further. For repeating work, combine it with a loop that calls Task.checkCancellation() at each yield point and an Atomic<Bool> flag set by the handler.

Confirmed Constraints

• Cancellation is cooperative — blocking synchronous code or non-cancellable system calls cannot be forcibly stopped.
• Task.sleep(for:) (Duration-based) requires iOS 16 / Swift 5.7; iOS 15 must use the nanoseconds overload.
• withTaskCancellationHandler's onCancel runs synchronously on the cancelling thread and must not await.
• TaskGroup cancellation only affects child tasks that respect cancellation; detached or unstructured tasks are unaffected.

Verification Steps

1. Create a minimal Xcode project targeting iOS 15 and iOS 16.
2. Implement the withTimeout pattern above and instrument with os_signpost or timestamp prints to confirm no work runs after timeout expiry.
3. Run under Thread Sanitizer (TSAN) to verify no data races on shared cancellation flags.
4. Consult Apple's Swift Concurrency documentation (Swift.org) and WWDC 2021/2022 session videos for official guidance.
5. Monitor Swift Evolution proposals (github.com/apple/swift-evolution) for any accepted timeout-related proposals post-2024.

One Diagnostic Detail

Are you targeting iOS 15 only, iOS 16+ only, or both? The answer determines whether you need the nanoseconds-based TaskGroup pattern alone or can also use withTaskCancellationHandler and Task.sleep(for:).