DispatchQueue: apa itu, antrian GCD dan dasar-dasar multi-threading

Apa itu DispatchQueue dan Grand Central Dispatch

DispatchQueue adalah objek dari framework Grand Central Dispatch (GCD) yang mengelola eksekusi tugas dalam antrian thread sistem atau kustom. Grand Central Dispatch adalah pustaka tingkat rendah Apple, tersedia sejak iOS 4 dan macOS 10.6, yang sepenuhnya mengabstraksi manajemen thread dari pengembang. GCD menggunakan pool thread sistem operasi dan secara otomatis menskalakan jumlah thread sesuai beban perangkat.

Pengembang tidak perlu membuat dan menghancurkan thread secara manual — GCD mengambil alih tugas ini, menyediakan API sederhana melalui DispatchQueue. Tugas dalam bentuk closure (penutupan) dikirim ke antrian melalui metode sync atau async. Dalam kasus pertama, thread pemanggil diblokir hingga tugas selesai, dalam kasus kedua — langsung melanjutkan eksekusi.

Menurut Apple (2026), GCD menggunakan pool thread sistem yang beradaptasi dengan jumlah inti dan beban prosesor saat ini. Antrian concurrent tidak membuat thread baru untuk setiap tugas — GCD menggunakan kembali thread dari pool, yang meminimalkan overhead pembuatan thread.

Arsitektur GCD

Grand Central Dispatch terdiri dari tiga komponen kunci: antrian (DispatchQueue), grup (DispatchGroup), dan semaphore (DispatchSemaphore). Antrian adalah elemen utama yang menerima tugas dalam bentuk blok kode. DispatchGroup menyinkronkan eksekusi beberapa tugas, dan DispatchSemaphore membatasi akses ke sumber daya bersama ke jumlah thread tertentu.

Setiap antrian GCD dikaitkan dengan kelas QoS (Quality of Service) tertentu yang memberi tahu sistem tentang pentingnya tugas. Sistem menggunakan QoS untuk mendistribusikan waktu prosesor antar antrian, memberikan prioritas pada tugas yang lebih kritis — misalnya, pembaruan UI atau pemrosesan sentuhan pengguna.

Antrian Serial dan Concurrent: perbandingan

Antrian Serial menjalankan tugas secara ketat berurutan, satu per satu. Jika tiga tugas ditempatkan dalam antrian serial, tugas kedua dimulai hanya setelah tugas pertama selesai sepenuhnya. Antrian serial digunakan untuk menyinkronkan akses ke sumber daya bersama — misalnya, ke array yang diubah dari beberapa bagian kode.

Antrian Concurrent menjalankan beberapa tugas secara simultan, mendistribusikannya ke thread yang tersedia dari pool sistem. Tugas pada antrian concurrent dimulai dalam urutan kedatangan (FIFO), tetapi selesai dalam urutan acak jika waktu eksekusinya berbeda. Antrian Concurrent tidak menjamin urutan penyelesaian — hanya urutan permulaan.

Kapan memilih antrian serial

Antrian serial ideal untuk tugas yang memodifikasi keadaan bersama — menulis ke file, memperbarui model data, atau bekerja dengan Core Data. Penggunaan antrian serial menjamin bahwa dua bagian kode tidak akan mengubah data yang sama secara bersamaan, menghilangkan kondisi balapan tanpa penguncian tambahan.

Kapan memilih antrian concurrent

Antrian Concurrent cocok untuk tugas yang tidak saling bergantung: memuat beberapa gambar, permintaan jaringan paralel, atau pemrosesan data batch. GCD secara otomatis memutuskan berapa banyak tugas yang akan dijalankan secara simultan, berdasarkan jumlah inti prosesor dan beban sistem saat ini.

Quality of Service: prioritas eksekusi tugas

QoS (Quality of Service) — mekanisme GCD yang memberi tahu sistem operasi tentang pentingnya dan urgensi tugas. Sistem menggunakan QoS untuk penjadwalan thread: tugas dengan QoS lebih tinggi mendapatkan lebih banyak waktu prosesor dan dimulai lebih awal. Nilai QoS ditransmisikan saat membuat antrian atau mengirim tugas tertentu.

Di GCD tersedia lima kelas QoS. .userInteractive — prioritas tertinggi untuk tugas terkait UI. .userInitiated — untuk tugas yang dimulai oleh pengguna. .utility — untuk tugas latar belakang dengan tampilan kemajuan. .background — untuk tugas yang tidak terlihat oleh pengguna. .default — tingkat menengah antara userInitiated dan utility, digunakan secara default.

Menurut Apple (2026), pemilihan QoS yang salah adalah salah satu penyebab umum masalah kinerja. Menjalankan unduhan latar belakang dengan QoS .userInteractive mengambil sumber daya dari UI, menyebabkan mikro-lag dalam animasi. Disarankan untuk memilih QoS terendah yang masih memberikan waktu eksekusi yang dapat diterima.

Contoh penerapan QoS

Saat memuat gambar untuk ditampilkan segera, gunakan .userInitiated — pengguna mengharapkan hasil. Untuk pramuat layar berikutnya, .utility sudah cukup. Sinkronisasi latar belakang dengan server dijalankan dengan .background, meminimalkan dampak pada tugas aktif.

DispatchGroup dan semaphore: sinkronisasi tugas

DispatchGroup memungkinkan pelacakan penyelesaian sekelompok tugas. Ketika semua tugas dalam grup selesai, GCD memanggil handler notify pada antrian yang ditentukan. Ini sangat berguna saat memuat beberapa sumber daya independen — data profil, daftar teman, dan pengaturan — ketika antarmuka perlu diperbarui hanya setelah semua data diterima.

DispatchGroup mendukung panggilan sinkron wait() yang memblokir thread saat ini hingga semua tugas selesai. Ini nyaman ketika kode tidak dapat berlanjut tanpa hasil grup. Varian asinkron — notify() — memanggil closure pada antrian yang ditentukan setelah semua tugas selesai, tanpa memblokir thread pemanggil.

DispatchSemaphore untuk membatasi paralelisme

DispatchSemaphore mengontrol akses ke sumber daya, membatasi jumlah akses simultan. Semaphore dengan nilai awal 3 memungkinkan menjalankan tidak lebih dari tiga tugas paralel. Saat wait() dipanggil, penghitung berkurang, saat signal() — bertambah. Jika penghitung nol, thread diblokir hingga sumber daya dibebaskan.

Contoh kode dengan DispatchQueue di Swift

Mari kita lihat tiga contoh praktis penggunaan DispatchQueue di Swift. Pertama menunjukkan panggilan async dasar dengan kembali ke thread utama, kedua — sinkronisasi melalui antrian serial, ketiga — DispatchGroup untuk permintaan paralel.

Panggilan async dasar dengan kembali ke main

DispatchQueue.main adalah antrian serial dari thread utama, ditujukan khusus untuk operasi UI. Selalu gunakan untuk memperbarui antarmuka setelah pekerjaan latar belakang selesai.

let queue = DispatchQueue.global(qos: .userInitiated)
queue.async {
    let data = self.fetchData()
    DispatchQueue.main.async {
        self.updateUI(with: data)
    }
}

Antrian serial untuk melindungi sumber daya bersama

Membuat antrian serial Anda sendiri dengan pengidentifikasi unik menyinkronkan akses ke array yang dapat diubah. Semua operasi baca dan tulis melewati satu antrian, menghilangkan kondisi balapan.

let serialQueue = DispatchQueue(label: "com.app.items")
var items: [Int] = []

serialQueue.async {
    items.append(1)
}
serialQueue.async {
    let last = items.last
    DispatchQueue.main.async {
        print("Last item: \(last)")
    }
}

DispatchGroup untuk permintaan paralel

DispatchGroup memungkinkan menjalankan beberapa tugas pada antrian concurrent dan menerima pemberitahuan saat semuanya selesai. Ini berguna saat memuat data untuk layar profil.

let group = DispatchGroup()
let worker = DispatchQueue.global()

worker.async(group: group) { self.loadProfile() }
worker.async(group: group) { self.loadFriends() }
worker.async(group: group) { self.loadSettings() }

group.notify(queue: DispatchQueue.main) {
    self.showCompleteUI()
}

Kesalahan umum saat bekerja dengan DispatchQueue

Deadlock saat panggilan sync pada antrian serial — kesalahan paling umum. Jika tugas pada antrian serial memanggil queue.sync pada antrian yang sama, thread diblokir selamanya. Antrian menunggu penyelesaian tugas saat ini, dan tugas menunggu penyelesaian panggilan sync — kebuntuan timbal balik klasik.

Memperbarui UI dari thread latar belakang

Semua operasi dengan UIKit harus dilakukan di thread utama. Xcode mendeteksi kesalahan ini dalam mode Debug melalui Main Thread Checker. Dalam build Release, hal ini menyebabkan perilaku tidak terduga: animasi tidak berjalan, UI tidak diperbarui, kemungkinan crash.

Pembuatan antrian kustom yang berlebihan

Membuat ratusan antrian kustom alih-alih antrian global — anti-pola. Setiap antrian mengonsumsi sumber daya sistem. Untuk sebagian besar tugas, antrian concurrent global dengan QoS berbeda dan satu-dua antrian serial untuk sinkronisasi data bersama sudah cukup.

Mengabaikan autoreleasepool dalam loop

Saat menjalankan tugas siklik intensif sumber daya pada antrian latar belakang tanpa autoreleasepool, memori bertambah hingga seluruh loop selesai. ARC membebaskan objek hanya saat keluar dari autorelease pool. Bungkus iterasi loop dalam autoreleasepool { } untuk pembebasan memori tepat waktu.