Five requests fail with 401 at the same moment. How do you refresh the token once, retry each request once, and avoid a loop?

Predict first

Five concurrent calls hit an expired token. How many refresh requests are sent?

import Foundation

struct Unauthorized: Error {}
actor TokenStore {
    private(set) var token = "old"
    private var refreshing: Task<String, Error>?
    private(set) var refreshCalls = 0
    func validToken() -> String { token }
    func refresh(stale: String) async throws -> String {
        if token != stale { return token }
        if let task = refreshing { return try await task.value }
        let task = Task { () -> String in
            try await Task.sleep(nanoseconds: 50_000_000)
            return "new"
        }
        refreshing = task
        refreshCalls += 1
        defer { refreshing = nil }
        token = try await task.value
        return token
    }
}
let store = TokenStore()

func call(_ id: Int) async throws -> String {
    var token = await store.validToken()
    for attempt in 0..<2 {
        if token == "new" { return "call \(id) ok" }
        if attempt == 1 { throw Unauthorized() }
        token = try await store.refresh(stale: token)
    }
    throw Unauthorized()
}
let results = try await withThrowingTaskGroup(of: String.self) { g -> [String] in
    for i in 1...5 { g.addTask { try await call(i) } }
    var r: [String] = []
    for try await v in g { r.append(v) }
    return r
}
print(results.count, "calls succeeded")
print("refresh requests sent:", await store.refreshCalls)

• 5 calls succeeded / refresh requests sent: 1
• 5 calls succeeded / refresh requests sent: 5
• 1 calls succeeded / refresh requests sent: 1