iOS Developer Roadmap: Đa Luồng trong Swift: Sử Dụng GCD, Hàng Đợi và Operations

Xin chào các bạn đồng nghiệp và những người đang trên con đường trở thành lập trình viên iOS! Chào mừng các bạn quay trở lại với chuỗi bài viết “Lộ trình học Lập trình viên iOS 2025“. Sau khi đã làm quen với những kiến thức nền tảng về Swift, UIKit/SwiftUI, quản lý bộ nhớ, và xử lý lỗi, đã đến lúc chúng ta bước vào một chủ đề quan trọng, quyết định đến trải nghiệm người dùng và hiệu năng ứng dụng: Đa Luồng (Multithreading).

Trong thế giới di động, không gì khó chịu hơn một ứng dụng bị “đơ” hay giật lag khi đang thực hiện một tác vụ nặng. Đó là lúc chúng ta cần đến đa luồng. Thay vì dồn hết công việc vào một “luồng” duy nhất (thường là luồng chính – main thread), chúng ta phân tán chúng ra các luồng khác, cho phép ứng dụng vừa làm việc nặng ở “hậu trường”, vừa giữ cho giao diện người dùng luôn mượt mà, phản hồi tức thời.

Trong bài viết này, chúng ta sẽ tập trung vào ba công cụ mạnh mẽ mà Apple cung cấp trong Swift để làm việc với đa luồng: Grand Central Dispatch (GCD), Dispatch Queues, và Operation/OperationQueue. Mặc dù Swift Concurrency với async/await đang trở nên phổ biến hơn (chúng ta đã thảo luận trong bài “Đa luồng trong Swift: GCD hay async/await?“), việc hiểu rõ GCD và Operations vẫn là nền tảng cực kỳ quan trọng, bởi lẽ chúng vẫn được sử dụng rộng rãi trong các ứng dụng hiện có và là cơ sở cho nhiều API khác của hệ thống.

Tại Sao Cần Đa Luồng? Vấn Đề Của Luồng Chính (Main Thread)

Mỗi ứng dụng iOS đều có ít nhất một luồng thực thi: Luồng Chính (Main Thread). Luồng này đóng vai trò cực kỳ quan trọng. Nó là nơi xử lý tất cả các sự kiện tương tác với người dùng (chạm, vuốt, nhập liệu), cập nhật giao diện người dùng (UI) thông qua các framework như UIKit hoặc SwiftUI, và là “trái tim” phản hồi của ứng dụng.

Nếu bạn thực hiện một công việc tốn thời gian (ví dụ: tải dữ liệu lớn từ mạng, xử lý ảnh phức tạp, đọc/ghi file nặng) trực tiếp trên luồng chính, luồng này sẽ bị “khóa” lại cho đến khi công việc hoàn thành. Trong khoảng thời gian đó, luồng chính không thể xử lý các sự kiện UI hay cập nhật giao diện. Kết quả là: ứng dụng của bạn trở nên không phản hồi, giao diện bị đứng yên, gây ra trải nghiệm rất tệ cho người dùng.

Đa luồng giải quyết vấn đề này bằng cách cho phép bạn chuyển các công việc tốn thời gian sang thực thi trên các luồng nền (background threads). Luồng chính được giải phóng để tiếp tục xử lý UI, còn công việc nặng sẽ được xử lý song song ở “hậu trường”. Khi công việc nền hoàn thành, kết quả có thể được đưa trở lại luồng chính để cập nhật giao diện một cách an toàn.

Grand Central Dispatch (GCD): Nền Tảng Mạnh Mẽ

Grand Central Dispatch (GCD) là một API cấp thấp, dựa trên C (nhưng được tích hợp liền mạch trong Swift), giúp chúng ta quản lý và thực thi các tác vụ song song một cách hiệu quả. GCD không yêu cầu bạn tự tạo và quản lý các luồng một cách thủ công (điều này rất phức tạp và dễ gây lỗi). Thay vào đó, bạn chỉ cần định nghĩa các “công việc” (dưới dạng closures hoặc function) và thêm chúng vào các “hàng đợi” (Queues). GCD sẽ tự động quản lý một pool các luồng để thực thi các công việc trong các hàng đợi đó.

Dispatch Queues: Nơi Công Việc Được Xếp Hàng

Trái tim của GCD là các Dispatch Queues. Hàng đợi là cấu trúc dữ liệu (queue) nơi các công việc chờ đợi để được thực thi. GCD lấy công việc từ các hàng đợi và thực thi chúng trên các luồng sẵn có. Có hai loại hàng đợi chính:

1. Hàng đợi Nối tiếp (Serial Queue):
   • Chỉ thực thi một công việc tại một thời điểm.
   • Công việc được thực thi theo thứ tự mà chúng được thêm vào hàng đợi (First-In, First-Out – FIFO).
   • Thường được sử dụng để bảo vệ các tài nguyên dùng chung (ví dụ: biến, cơ sở dữ liệu) khỏi bị truy cập đồng thời từ nhiều luồng, tránh tình trạng race condition.
2. Hàng đợi Đồng thời (Concurrent Queue):
   • Có thể thực thi nhiều công việc cùng một lúc, song song với nhau (số lượng công việc song song tùy thuộc vào tài nguyên hệ thống và cấu hình của hàng đợi).
   • Công việc vẫn được lấy từ hàng đợi theo thứ tự FIFO, nhưng thứ tự hoàn thành có thể không giống thứ tự bắt đầu.
   • Thường được sử dụng cho các công việc độc lập có thể chạy song song để tận dụng hiệu quả các lõi xử lý.

Các Loại Hàng Đợi Có Sẵn

GCD cung cấp một số hàng đợi được tạo sẵn:

• Hàng đợi Chính (Main Dispatch Queue):
  • Đây là hàng đợi nối tiếp (serial) toàn cục duy nhất trong ứng dụng của bạn.
  • Tất cả các cập nhật UI phải được thực hiện trên hàng đợi này.
  • Bạn truy cập nó thông qua DispatchQueue.main.
• Hàng đợi Toàn cục (Global Dispatch Queues):
  • Đây là các hàng đợi đồng thời (concurrent) được chia sẻ trên toàn hệ thống.
  • Chúng được phân loại theo Chất lượng Dịch vụ (Quality of Service – QoS), cho phép bạn ưu tiên các công việc quan trọng hơn:
    • .userInteractive: Công việc cần phản hồi tức thời từ người dùng (ví dụ: animation, xử lý sự kiện UI). Ưu tiên cao nhất.
    • .userInitiated: Công việc do người dùng khởi tạo và cần kết quả nhanh (ví dụ: tải nội dung người dùng yêu cầu).
    • .utility: Công việc chạy dài hơn, không yêu cầu kết quả ngay lập tức, có thể hiển thị progress bar (ví dụ: tải xuống lớn, xử lý dữ liệu). Tiết kiệm năng lượng hơn .userInitiated.
    • .background: Công việc chạy ngầm, không hiển thị trực tiếp cho người dùng, có thể mất nhiều thời gian (ví dụ: đồng bộ hóa dữ liệu nền, dọn dẹp cache). Ưu tiên thấp nhất, tiết kiệm năng lượng nhất.
    • .default: Mức ưu tiên mặc định, giữa .userInitiated và .utility.
    • .unspecified: Không có thông tin QoS, hệ thống sẽ suy đoán hoặc sử dụng mức mặc định.
  • Bạn truy cập chúng thông qua DispatchQueue.global(qos: .yourLevel).

Tạo Hàng Đợi Tùy Chỉnh (Custom Queues)

Bạn cũng có thể tạo hàng đợi của riêng mình, có thể là nối tiếp hoặc đồng thời:

let mySerialQueue = DispatchQueue(label: "com.myapp.mySerialQueue")
let myConcurrentQueue = DispatchQueue(label: "com.myapp.myConcurrentQueue", attributes: .concurrent)

Việc sử dụng hàng đợi nối tiếp tùy chỉnh rất hữu ích khi bạn cần bảo vệ một tài nguyên cụ thể (ví dụ: một mảng dữ liệu) chỉ cho phép một luồng truy cập tại một thời điểm, mà không làm tắc nghẽn luồng chính hoặc các hàng đợi toàn cục khác.

Dispatching Work: `async` và `sync`

Để thêm công việc vào hàng đợi, bạn sử dụng các phương thức async hoặc sync:

• async (Asynchronous):
  • Thêm công việc vào hàng đợi và trả về ngay lập lập tức.
  • Công việc sẽ được thực thi trên một luồng phù hợp được quản lý bởi GCD.
  • Luồng hiện tại (nơi bạn gọi async) không bị chặn. Đây là cách phổ biến nhất để gửi công việc ra khỏi luồng chính.
• sync (Synchronous):
  • Thêm công việc vào hàng đợi và chờ đợi cho đến khi công việc đó hoàn thành.
  • Luồng hiện tại (nơi bạn gọi sync) sẽ bị khóa (blocked) cho đến khi công việc trên hàng đợi được thực thi xong.
  • Cực kỳ cẩn thận: Không bao giờ gọi sync trên cùng hàng đợi mà bạn đang đứng. Ví dụ, gọi DispatchQueue.main.sync { ... } từ chính luồng chính sẽ gây ra deadlock (bế tắc), làm ứng dụng bị treo vĩnh viễn. Tuy nhiên, gọi someOtherQueue.sync { ... } từ luồng chính là hợp lệ (mặc dù vẫn chặn luồng chính cho đến khi công việc trên someOtherQueue hoàn thành).

Ví dụ: Tải ảnh nền và cập nhật UI

// Giả lập một hàm tải ảnh tốn thời gian
func downloadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
    print("Bắt đầu tải ảnh...")
    // Thực hiện công việc nặng trên hàng đợi nền (global queue)
    DispatchQueue.global(qos: .userInitiated).async {
        // Đây là nơi bạn thực hiện việc tải dữ liệu thực tế
        // Ví dụ đơn giản: sleep để giả lập độ trễ
        Thread.sleep(forTimeInterval: 2)
        let dummyImage: UIImage? = nil // Giả lập kết quả tải về
        print("Tải ảnh hoàn thành.")

        // Cập nhật UI PHẢI trên luồng chính
        DispatchQueue.main.async {
            completion(dummyImage)
            print("UI đã cập nhật.")
        }
    }
}

// Cách sử dụng
let imageUrl = URL(string: "https://example.com/image.jpg")!
downloadImage(from: imageUrl) { image in
    // Cập nhật UIImageView trên luồng chính
    // imageView.image = image
    print("Closure cập nhật UI trên Main Thread được gọi.")
}
print("Hàm downloadImage đã trả về ngay lập tức.") // Dòng này sẽ in ra trước "Bắt đầu tải ảnh..."

Ví dụ trên minh họa cách sử dụng async trên hàng đợi toàn cục để thực hiện công việc nền và sau đó sử dụng async trên DispatchQueue.main để quay lại luồng chính cập nhật giao diện một cách an toàn.

DispatchGroup: Đồng Bộ Hóa Nhóm Tác Vụ

Khi bạn cần thực hiện nhiều công việc song song và muốn biết khi nào tất cả chúng hoàn thành để thực hiện một tác vụ cuối cùng (ví dụ: cập nhật UI sau khi tất cả các request mạng đã về), bạn có thể sử dụng DispatchGroup.

let group = DispatchGroup()
let globalQueue = DispatchQueue.global(qos: .userInitiated)

// Công việc 1
globalQueue.async(group: group) {
    print("Công việc 1 bắt đầu")
    Thread.sleep(forTimeInterval: 1)
    print("Công việc 1 kết thúc")
}

// Công việc 2
globalQueue.async(group: group) {
    print("Công việc 2 bắt đầu")
    Thread.sleep(forTimeInterval: 3)
    print("Công việc 2 kết thúc")
}

// Notify khi tất cả công việc trong group hoàn thành
group.notify(queue: .main) {
    print("Tất cả công việc đã hoàn thành. Cập nhật UI tại đây!")
    // Ví dụ: end activity indicator, reload table view, etc.
}

print("Đã gửi công việc vào group.") // Dòng này in ra đầu tiên

Bạn dùng group.enter() trước khi bắt đầu một tác vụ trong nhóm và group.leave() khi tác vụ đó hoàn thành. Phương thức async(group: group) { ... } tiện lợi hơn, nó tự động gọi enter/leave cho bạn.

Operation và OperationQueue: Tầng Trừu Tượng Cao Hơn

Trong khi GCD cung cấp một API cấp thấp linh hoạt, Operation và OperationQueue cung cấp một mô hình lập trình hướng đối tượng (OOP) để quản lý các tác vụ đồng thời.

Operation là một lớp trừu tượng đại diện cho một đơn vị công việc. Bạn thường không sử dụng trực tiếp lớp Operation mà dùng các lớp con cụ thể hoặc tự tạo lớp con cho riêng mình:

• BlockOperation: Một lớp con đơn giản để gói gọn một hoặc nhiều closures. Khi BlockOperation thực thi, nó chạy tất cả các closures được thêm vào trên các luồng phù hợp.
• URLSessionTaskOperation (trong một số thư viện/framework): Ví dụ về lớp con Operation cho các tác vụ mạng.
• Tự tạo lớp con Operation: Bạn có thể tạo lớp con của Operation để đóng gói các công việc phức tạp, có trạng thái riêng (pending, executing, finished, cancelled). Điều này đòi hỏi bạn phải quản lý trạng thái và luồng thực thi một cách cẩn thận hơn.

OperationQueue là một hàng đợi quản lý việc thực thi các đối tượng Operation. Nó tương tự như một dispatch queue đồng thời (concurrent dispatch queue) nhưng có nhiều tính năng nâng cao hơn.

Các Tính Năng Nổi Bật của Operations/OperationQueue

• Dependencies (Sự Phụ thuộc): Bạn có thể định nghĩa rằng một Operation chỉ được phép bắt đầu sau khi một Operation khác đã hoàn thành. Đây là một tính năng rất mạnh mẽ cho các workflow phức tạp, nơi thứ tự thực hiện các bước là quan trọng.

  let operationA = BlockOperation { print("Operation A hoàn thành") }
  let operationB = BlockOperation { print("Operation B hoàn thành, sau A") }
  
  // B phụ thuộc vào A
  operationB.addDependency(operationA)
  
  let operationQueue = OperationQueue()
  operationQueue.addOperation(operationA)
  operationQueue.addOperation(operationB) // B sẽ chờ A xong mới chạy
  

• Cancellation (Hủy bỏ): Việc hủy bỏ một Operation đang chạy hoặc đang chờ trong hàng đợi trở nên dễ dàng hơn thông qua phương thức cancel(). Operation cần kiểm tra thuộc tính isCancelled và dừng công việc của nó một cách duyên dáng.
• Quan sát Trạng thái (State Observation): Operation có các thuộc tính trạng thái (isReady, isExecuting, isFinished, isCancelled) và bạn có thể sử dụng KVO (Key-Value Observing) để theo dõi sự thay đổi trạng thái của chúng.
• Quản lý Số Lượng Công Việc Đồng Thời (Max Concurrent Operation Count): Bạn có thể dễ dàng kiểm soát số lượng Operation được thực thi cùng lúc trong một OperationQueue bằng cách đặt thuộc tính maxConcurrentOperationCount. Đặt giá trị này bằng 1 sẽ biến OperationQueue thành một hàng đợi nối tiếp.

  let serialOperationQueue = OperationQueue()
  serialOperationQueue.maxConcurrentOperationCount = 1 // Biến thành hàng đợi nối tiếp
  

Ví dụ: Sử dụng BlockOperation

let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 2 // Cho phép tối đa 2 operation chạy cùng lúc

let task1 = BlockOperation {
    print("Task 1 đang chạy...")
    Thread.sleep(forTimeInterval: 2)
    print("Task 1 hoàn thành")
}

let task2 = BlockOperation {
    print("Task 2 đang chạy...")
    Thread.sleep(forTimeInterval: 1)
    print("Task 2 hoàn thành")
}

let task3 = BlockOperation {
    print("Task 3 đang chạy...")
    Thread.sleep(forTimeInterval: 3)
    print("Task 3 hoàn thành")
}

operationQueue.addOperation(task1)
operationQueue.addOperation(task2)
operationQueue.addOperation(task3)

print("Đã thêm các task vào queue")
// Output có thể khác nhau tùy thuộc vào thời gian chạy, nhưng Task 1 và Task 2/3 có thể chạy song song (tối đa 2)
// Task 1 đang chạy...
// Task 2 đang chạy...
// Task 2 hoàn thành
// Task 3 đang chạy...
// Task 1 hoàn thành
// Task 3 hoàn thành

GCD vs. Operations: Lựa Chọn Nào?

GCD và Operations đều phục vụ mục đích thực thi các công việc song song hoặc bất đồng bộ, nhưng chúng có những điểm mạnh và trường hợp sử dụng khác nhau.

Dưới đây là bảng so sánh giúp bạn dễ hình dung:

Trong thực tế, bạn có thể và sẽ sử dụng cả hai trong cùng một ứng dụng. GCD thường được dùng cho những việc đơn giản và nhanh chóng, còn Operations được dùng cho các hệ thống phức tạp hơn, cần quản lý tốt hơn về trạng thái và phụ thuộc.

Các Lỗi Thường Gặp và Thực Hành Tốt Nhất

Làm việc với đa luồng có thể dẫn đến các lỗi khó debug như race condition, deadlock hoặc cập nhật UI sai luồng. Dưới đây là một số điểm cần lưu ý:

• Luôn cập nhật UI trên Luồng Chính: Đây là quy tắc vàng. Bất kỳ thay đổi nào đối với các đối tượng UI (như UILabel, UIImageView, UITableView, hay các View trong SwiftUI) đều phải được thực hiện trên DispatchQueue.main.

  // Sai: Cập nhật UI trên luồng nền
  // DispatchQueue.global().async {
  //     myLabel.text = "Hoàn thành"
  // }
  
  // Đúng: Cập nhật UI trên luồng chính
  DispatchQueue.main.async {
      myLabel.text = "Hoàn thành"
  }
  

• Tránh Deadlock với sync: Như đã nói ở trên, không bao giờ gọi .sync trên hàng đợi hiện tại. Đặc biệt, tránh DispatchQueue.main.sync { ... } khi đang trên luồng chính.
• Cẩn thận với Chu trình Tham chiếu Mạnh (Strong Reference Cycles): Khi sử dụng closures trong các block GCD hoặc Operations, hãy lưu ý đến việc capture self. Nếu closure giữ tham chiếu mạnh đến self, và đối tượng self cũng giữ tham chiếu mạnh đến closure (hoặc đối tượng chứa closure), bạn có thể tạo ra một chu trình tham chiếu mạnh, dẫn đến rò rỉ bộ nhớ. Sử dụng capture list ([weak self] hoặc [unowned self]) để phá vỡ chu trình này. Chúng ta đã tìm hiểu kỹ về vấn đề này trong bài viết về Quản Lý Bộ Nhớ trong Swift: ARC, Tham Chiếu và Các Thức Hành Tốt Nhất và Closures trong Swift: Chúng là gì và Cách Sử Dụng Chúng Một Cách An Toàn.

  class MyClass {
      var name = "Test"
  
      func performTask() {
          DispatchQueue.global().async { [weak self] in // Sử dụng [weak self]
              guard let self = self else { return } // Kiểm tra self còn tồn tại không
              print("Thực hiện tác vụ với \(self.name)")
              // ... công việc nền ...
              DispatchQueue.main.async {
                  self.updateUI()
              }
          }
      }
  
      func updateUI() {
          // Cập nhật UI
          print("Cập nhật UI")
      }
  }
  

• Race Conditions: Xảy ra khi nhiều luồng truy cập và cố gắng thay đổi cùng một tài nguyên dùng chung (biến, mảng, dictionary) mà không có cơ chế đồng bộ hóa phù hợp. Kết quả cuối cùng có thể không thể đoán trước và phụ thuộc vào luồng nào thực thi trước. Sử dụng hàng đợi nối tiếp (serial queue) hoặc các cơ chế khóa khác (như NSRecursiveLock, NSLock, hoặc các kỹ thuật của GCD/OperationQueue) để bảo vệ các tài nguyên dùng chung.
• Chọn QoS Phù hợp: Sử dụng đúng mức QoS cho công việc của bạn giúp hệ thống quản lý tài nguyên hiệu quả hơn, ưu tiên các tác vụ quan trọng và tiết kiệm pin cho các tác vụ nền.

Kết Luận

Việc làm chủ đa luồng là một kỹ năng thiết yếu đối với bất kỳ lập trình viên iOS nào muốn xây dựng các ứng dụng mượt mà, phản hồi nhanh và hiệu quả. GCD và Operations/OperationQueue là hai bộ công cụ chính được sử dụng trong Swift để đạt được điều này.

GCD cung cấp sự linh hoạt và hiệu năng cấp thấp cho các tác vụ đơn giản và quản lý hàng đợi cơ bản. Operations và OperationQueue, với mô hình hướng đối tượng và các tính năng như dependencies, cancellation, cung cấp một giải pháp mạnh mẽ và có cấu trúc hơn cho các công việc phức tạp.

Hãy thực hành sử dụng cả hai API này trong các dự án của bạn. Bắt đầu với việc đưa các tác vụ tốn thời gian ra khỏi luồng chính bằng DispatchQueue.global().async { ... } và đưa kết quả trở lại luồng chính với DispatchQueue.main.async { ... }. Khi gặp các kịch bản phức tạp hơn cần sự phụ thuộc hoặc hủy bỏ dễ dàng, hãy nghĩ đến Operations.

Đừng quên theo dõi các bài viết tiếp theo trong chuỗi “Lộ trình học Lập trình viên iOS 2025” để tiếp tục nâng cao kiến thức và kỹ năng của mình nhé!