Lộ Trình Học Lập Trình Viên iOS 2025: Callback Hell trong Swift và Cách Tránh Xa Nó

Callback Hell trong Swift không chỉ là vài tầng closure thụt lề xấu mắt. Khi mỗi bước mạng phụ thuộc bước trước, lỗi phải đi qua nhiều callback, UI phải đổi thread và vòng đời của self không rõ ràng, một thay đổi nhỏ cũng có thể tạo ra lỗi khó tái hiện. Với Swift 6.4 và Xcode 27.2, bạn nên xem async/await là đường chính cho code mới, nhưng vẫn cần biết cách nối an toàn với các API callback legacy.

Cập nhật 2026: Callback Hell nhìn từ Swift Concurrency

  • Swift 6.4.2 là bản cài đặt hiện tại trong bộ công cụ Swift 6.4; strict concurrency checking khiến việc truyền dữ liệu giữa các isolation domain, capture self và cập nhật UI sai actor lộ ra sớm hơn.
  • iOS 27.2 và Xcode 27.2 là nền tảng ổn định hiện tại. API async/await của URLSession nên được ưu tiên khi deployment target của ứng dụng cho phép.
  • Task, async let, withThrowingTaskGroup và AsyncSequence là các công cụ concurrency mặc định cho luồng công việc mới. GCD vẫn hợp lệ ở lớp hạ tầng hoặc khi bạn phải giao tiếp với thư viện cũ.

Callback Hell thực sự gây hại ở đâu?

Giả sử màn hình cần lấy hồ sơ người dùng, lấy các bài viết của người đó rồi tải ảnh đại diện. Với API cũ, mỗi hàm nhận một completion handler. Completion có thể được gọi ở background queue, trả về Result hoặc trả lỗi qua tham số riêng. Khi nối ba bước, code tạo thành “pyramid of doom”: nhánh thành công nằm sâu bên trong, còn mỗi nhánh lỗi lại lặp lại ở một cấp khác.

func loadScreen(completion: @escaping (Result<ScreenData, Error>) -> Void) {
    fetchUser { userResult in
        switch userResult {
        case .failure(let error): completion(.failure(error))
        case .success(let user):
            fetchPosts(userID: user.id) { postsResult in
                switch postsResult {
                case .failure(let error): completion(.failure(error))
                case .success(let posts):
                    guard let first = posts.first else {
                        completion(.failure(AppError.noPosts))
                        return
                    }
                    fetchAvatar(post: first) { avatarResult in
                        switch avatarResult {
                        case .failure(let error): completion(.failure(error))
                        case .success(let avatar):
                            completion(.success(ScreenData(user: user,
                                                            posts: posts,
                                                            avatar: avatar)))
                        }
                    }
                }
            }
        }
    }
}

Vấn đề không chỉ là indentation. Luồng lỗi bị phân tán, trạng thái trung gian phải sống qua nhiều closure, và callback có thể quên gọi completion ở một nhánh. Nếu callback giữ mạnh view controller, request kéo dài có thể giữ cả màn hình; nếu dùng [weak self] quá sớm, kết quả lại bị bỏ qua mà không có log hay trạng thái lỗi rõ ràng.

Bốn loại lỗi thường đi cùng nhau

  • Truyền lỗi. Một callback nuốt lỗi bằng print, callback kế tiếp không biết request thất bại và UI cứ ở trạng thái loading.
  • Retain cycle. Object giữ task hoặc client; closure giữ mạnh self; self lại giữ token hoặc closure. Màn hình rời đi nhưng request và dữ liệu vẫn còn sống.
  • Threading. Completion từ networking thường không phải main thread. Chạm vào state của SwiftUI hoặc UIKit ngay trong đó có thể gây warning, race hoặc lỗi giao diện.
  • Thứ tự và hủy. Một callback cũ có thể về sau lần tải mới và ghi đè dữ liệu mới. “Hủy” request cũng không tự động dừng mọi callback nếu API không hỗ trợ cancellation.

Named functions và OperationQueue có thể giảm độ sâu, nhưng không làm mất bản chất callback. Operation phù hợp với một pipeline cần dependency và giới hạn số việc chạy song song; với một chuỗi gọi mạng thông thường, nó dễ tạo thêm state dùng chung và semaphore. Nếu bạn đang ôn lại GCD, queue và operation, bài đa luồng trong Swift là phần liên quan trong roadmap.

Async/await làm phẳng chuỗi tuần tự

Async/await tách “cách chờ” khỏi “logic nghiệp vụ”. Hàm async có thể tạm dừng mà không chặn thread; throws đưa lỗi về cùng một luồng điều khiển với kết quả. Bạn đọc từ trên xuống dưới, đặt breakpoint theo từng bước và dùng một do/catch ở ranh giới thích hợp.

Trước và sau: ba request tuần tự

Bản chuyển đổi không nên chỉ đổi tên hàm. Hãy thiết kế error type có ý nghĩa để UI, log và retry phân biệt được lỗi mạng, phản hồi không hợp lệ và dữ liệu thiếu.

enum APIError: Error {
    case invalidResponse
    case missingAvatar
    case server(statusCode: Int)
}

struct User: Sendable { let id: String; let name: String }
struct Post: Sendable { let id: String; let title: String }
struct Avatar: Sendable { let url: URL }
struct ScreenData: Sendable {
    let user: User
    let posts: [Post]
    let avatar: Avatar
}

protocol APIClient: Sendable {
    func user() async throws -> User
    func posts(for userID: String) async throws -> [Post]
    func avatar(for post: Post) async throws -> Avatar
}

func loadScreen(client: some APIClient) async throws -> ScreenData {
    let user = try await client.user()
    let posts = try await client.posts(for: user.id)
    guard let first = posts.first else { throw APIError.missingAvatar }
    let avatar = try await client.avatar(for: first)
    return ScreenData(user: user, posts: posts, avatar: avatar)
}

func refresh(client: some APIClient) async {
    do {
        let data = try await loadScreen(client: client)
        print("Loaded \(data.posts.count) posts for \(data.user.name)")
    } catch is CancellationError {
        return
    } catch {
        print("Load failed: \(error)")
    }
}

Điểm đáng chú ý là lỗi không bị biến thành một giá trị “đã xử lý” ở mỗi tầng. Hàm gọi quyết định làm gì: hiển thị nút thử lại, ghi log, bỏ qua khi người dùng đã rời màn hình, hay chuyển lỗi thành một trạng thái domain. Đó là cách xử lý lỗi trong Swift trở nên nhất quán hơn.

Đưa kết quả lên UI với Task và @MainActor

Đừng mặc định mọi hàm async đều chạy trên main thread, cũng đừng tự chuyển queue bằng GCD sau mỗi await. Đánh dấu model điều khiển UI bằng @MainActor; phần networking có thể chạy ngoài main actor, còn các phép gán state được compiler bảo vệ.

@MainActor
final class ScreenModel {
    enum State {
        case idle
        case loading
        case loaded(ScreenData)
        case failed(String)
    }

    private(set) var state: State = .idle
    private var loadTask: Task<Void, Never>?

    func reload(client: some APIClient) {
        loadTask?.cancel()
        state = .loading
        loadTask = Task { [weak self, client] in
            do {
                let data = try await loadScreen(client: client)
                try Task.checkCancellation()
                self?.state = .loaded(data)
            } catch is CancellationError {
                return
            } catch {
                self?.state = .failed(String(describing: error))
            }
        }
    }

    deinit { loadTask?.cancel() }
}

Task {} kế thừa actor context của nơi tạo task, vì vậy cập nhật state trong ví dụ vẫn ở MainActor. [weak self] ngăn task giữ màn hình mãi, còn capture client theo giá trị giúp task không vô tình đọc một property thay đổi giữa chừng. Trong code production, bạn cũng có thể gắn task vào vòng đời view bằng .task của SwiftUI để framework tự hủy khi view biến mất.

Chạy song song: async let và TaskGroup

Không phải mọi thứ đều cần chạy tuần tự. Sau khi có user, nếu tải danh sách bài viết và cấu hình hồ sơ không phụ thuộc lẫn nhau, dùng async let. Hai child task bắt đầu gần như cùng thời điểm và lỗi được gom lại khi bạn await kết quả.

Trước và sau: hai request độc lập

// Trước: tổng thời gian gần bằng thời gian của cả hai request cộng lại.
let posts = try await client.posts(for: user.id)
let settings = try await client.settings(for: user.id)

// Sau: bắt đầu cùng lúc, chỉ await khi cần kết quả.
async let posts = client.posts(for: user.id)
async let settings = client.settings(for: user.id)
let (loadedPosts, loadedSettings) = try await (posts, settings)

async let phù hợp khi số tác vụ cố định và kiểu kết quả khác nhau. Khi số phần tử thay đổi, ví dụ tải thumbnail cho mọi bài viết, dùng throwing task group. Group quản lý vòng đời child task và cho phép bạn gom kết quả theo thứ tự hoàn thành.

func loadAvatars(for posts: [Post], client: some APIClient) async throws -> [Avatar] {
    try await withThrowingTaskGroup(of: Avatar.self, returning: [Avatar].self) { group in
        for post in posts {
            group.addTask {
                try Task.checkCancellation()
                return try await client.avatar(for: post)
            }
        }

        var avatars: [Avatar] = []
        for try await avatar in group {
            avatars.append(avatar)
        }
        return avatars
    }
}

Nếu một child task ném lỗi, group sẽ kết thúc theo chính sách throwing của nó; hãy quyết định rõ có cần hủy phần còn lại hay thu thập lỗi từng phần. Đừng dùng group để chạy vô hạn request không giới hạn. Với danh sách lớn, giới hạn concurrency hoặc chia batch để không làm nghẽn server và bộ nhớ.

Continuation: adapter an toàn cho API callback

Không phải SDK nội bộ hay thư viện bên thứ ba nào cũng có phiên bản async. Ranh giới adapter nên nằm ở data layer: callback chỉ xuất hiện một lần trong adapter, còn phần còn lại của app dùng async/await. withCheckedThrowingContinuation kiểm tra trong runtime rằng continuation được resume đúng cách, nhưng nó không thể sửa một API callback vốn gọi completion hai lần.

func legacyFetchUser(
    completion: @escaping (Result<User, Error>) -> Void
) -> CancellableRequest { fatalError("SDK legacy") }

func fetchUser() async throws -> User {
    try await withCheckedThrowingContinuation { continuation in
        let request = legacyFetchUser { result in
            switch result {
            case .success(let user): continuation.resume(returning: user)
            case .failure(let error): continuation.resume(throwing: error)
            }
        }
        // Nếu SDK hỗ trợ cancel, liên kết request với một lớp cancellation handler.
        _ = request
    }
}

Trong thực tế, continuation phải có đúng một đường resume cho mọi kết quả: success, failure và các trường hợp callback bị hủy. Nếu SDK có thể gọi completion hai lần, hãy sửa hoặc bọc nó bằng một guard đồng bộ ở boundary; không tắt kiểm tra bằng continuation không checked chỉ để che warning. Nếu SDK có thể không gọi completion, cần timeout hoặc cơ chế hủy rõ ràng, nếu không task sẽ chờ vô hạn.

Gắn cancellation với request legacy

func fetchUserSafely() async throws -> User {
    let box = RequestBox()
    return try await withTaskCancellationHandler(operation: {
        try await withCheckedThrowingContinuation { continuation in
            let request = legacyFetchUser { result in
                continuation.resume(with: result)
            }
            box.set(request)
        }
    }, onCancel: {
        box.cancel()
    })
}

RequestBox ở đây là một lớp nhỏ có khóa để lưu CancellableRequest, cung cấp set(_:) và cancel(); tên và cơ chế đồng bộ phụ thuộc SDK. Ý chính là cancellation phải đi được từ task tới request gốc. Nếu request đã bị hủy trước khi set, set phải hủy ngay request mới nhận. Không cập nhật UI sau khi nhận cancellation, và dùng try Task.checkCancellation() sau các bước không tự ném CancellationError.

Combine và RxSwift còn chỗ nào?

Combine vẫn hợp lý khi bạn mô hình hóa một luồng giá trị liên tục: debounce ô tìm kiếm, kết hợp nhiều publisher hoặc duy trì pipeline đã được kiểm thử. Tuy nhiên, một request tuần tự đơn lẻ thường rõ hơn với async/await. AnyCancellable cũng tạo thêm vòng đời subscription cần quản lý.

RxSwift có thể vẫn xuất hiện trong codebase lớn, nhưng theo fact base 2026 nó là lựa chọn legacy/maintenance-mode cho phần lớn dự án mới. Không cần thay cả ứng dụng trong một sprint: giữ pipeline Rx đang ổn định, tạo adapter tại boundary và chuyển use case mới sang async/await. Khi chuyển đổi, đừng biến Observable thành một lớp bọc continuation tùy tiện; hãy xác định đây là một giá trị duy nhất hay một stream để chọn async function hoặc AsyncSequence.

Tình huống Lựa chọn Lưu ý
Request có một kết quả async/await Dễ đọc, throws và cancellation rõ
Nhiều việc độc lập, số lượng cố định async let Await tuple kết quả
Nhiều phần tử động TaskGroup Giới hạn tải và chính sách lỗi
Stream liên tục hoặc pipeline cũ Combine/RxSwift Giữ ở boundary khi có lý do
SDK completion-only Continuation adapter Kiểm chứng resume một lần

Các bẫy cần kiểm tra trước khi merge

  • Resume hai lần hoặc không resume. Mỗi callback path phải gọi continuation đúng một lần. Test cả success, lỗi, timeout và callback bị hủy.
  • Nuốt lỗi. Không biến mọi failure thành mảng rỗng hoặc nil. Typed error giúp phân biệt retry được, đăng nhập lại, và lỗi dữ liệu không thể sửa.
  • Hiểu sai cancellation. cancel() chỉ gửi tín hiệu; code phải kiểm tra tín hiệu và API gốc phải hủy được. Đừng retry tự động một mutation đã gửi một phần.
  • Cập nhật UI sai actor. Để @MainActor bảo vệ model UI, không rải DispatchQueue.main.async sau từng callback. Với Swift 6 strict concurrency, xử lý warning thay vì gắn @preconcurrency tràn lan.
  • Retain cycle. Closure của client, task của view model và subscription đều có thể giữ nhau. Dùng capture list có chủ đích, hủy task khi rời màn hình và kiểm tra deinit bằng Instruments hoặc log test.
  • Retry mutation. Retry GET thường an toàn hơn retry POST/PUT. Nếu cần retry mutation, dùng idempotency key hoặc trạng thái server để tránh tạo đơn hàng, thanh toán hay bản ghi hai lần.

Quy trình migrate thực dụng

  1. Vẽ dependency graph của use case: bước nào bắt buộc tuần tự, bước nào độc lập, bước nào là stream.
  2. Định nghĩa typed errors và test các nhánh thất bại trước khi đổi signature.
  3. Đặt adapter callback-to-async ở data layer; không để continuation lan vào view controller.
  4. Chuyển request cố định sang async/await, dùng async let cho phần độc lập và TaskGroup cho tập động.
  5. Gắn task với vòng đời UI, đánh dấu state model bằng @MainActor, rồi bật strict concurrency theo từng module.
  6. Đo lại cancellation, retain cycle, retry và thứ tự kết quả bằng test bất đồng bộ trước khi xóa API cũ.

Swift 6.4 không biến mọi callback thành lỗi qua một đêm, nhưng nó làm ranh giới an toàn trở nên rõ ràng: dữ liệu nào có thể gửi qua task, state nào thuộc MainActor và lỗi nào phải được xử lý. Bài GCD hay async/await giúp bạn chọn công cụ theo ngữ cảnh; còn roadmap iOS là nơi đặt chủ đề concurrency vào toàn bộ lộ trình.

Nhìn tới 2027

Trong năm 2027, các codebase iOS mới sẽ tiếp tục dịch chuyển về strict concurrency và các abstraction dựa trên async sequence, trong khi phần legacy vẫn cần adapter. Đừng chờ một lần rewrite lớn: boundary nhỏ, typed error, test cancellation và actor isolation là những bước có thể triển khai ngay trong từng feature.