Queue adalah struktur data yang mengikuti prinsip First-In, First-Out (FIFO) elemen pertama yang masuk akan menjadi elemen pertama yang keluar. Layaknya antrian di bank atau kasir supermarket, queue memudahkan pengelolaan urutan tugas, permintaan, atau data dalam berbagai aplikasi: mulai dari print spooler, message broker, hingga job scheduling di sistem terdistribusi. 

Pada artikel ini, kita akan mengupas definisi queue, variasi utamanya, hingga contoh implementasi praktis dalam pemrograman.

Apa itu Data Queue

Data Queue adalah struktur data abstrak yang mengelola elemen secara berurutan dengan prinsip FIFO (First-In, First-Out). Queue menyediakan operasi dasar seperti enqueue (tambah data), dequeue (ambil data), peek (lihat data terdepan), dan isEmpty (cek kosong) . 

Terdapat berbagai varian Linear, Circular, Priority, dan Deque yang masing-masing cocok untuk kasus penggunaan berbeda, mulai dari penjadwalan proses di sistem operasi hingga message broker di arsitektur terdistribusi. Implementasi queue bisa dengan array, linked-list, atau library bawaan di berbagai bahasa pemrograman seperti Python, Java, dan C++ .

Fungsi Struktur Data Queue

Setelah memahami apa itu queue dan variannya, berikut fungsi‐fungsi dasar yang disediakan oleh struktur data Queue untuk mengelola elemen secara FIFO:

Enqueue (Menambahkan Elemen)

Menempatkan elemen baru di ujung belakang (rear) antrian.

• Use case: mengantri tugas baru, misal permintaan cetak atau pesan masuk.
• Complexity: O(1).

Dequeue (Mengeluarkan Elemen)

Mengambil dan menghapus elemen di ujung depan (front) antrian.

• Use case: memproses tugas tertua, misal mengirim email pertama dalam antrean.
• Complexity: O(1).

Peek / Front (Melihat Elemen Depan)

Melihat nilai elemen paling depan tanpa mengeluarkannya.

• Use case: memeriksa tugas berikutnya tanpa mengubah antrean.

isEmpty (Cek Kosong)

Mengembalikan true jika antrian kosong, false jika masih ada elemen.

• Use case: menghindari error dequeue pada antrian kosong.

isFull (Cek Penuh)** — hanya pada bounded/circular queue

Mengembalikan true jika kapasitas maksimum tercapai, mencegah overflow.

• Use case: menunggu sebelum enqueue lebih lanjut pada buffer terbatas.

size (Menghitung Elemen)

Memberi jumlah elemen saat ini di dalam queue.

• Use case: memonitor panjang antrean untuk skala dinamis (auto-scaling).

Tipe-Tipe Queue

Ada empat varian queue yang umum dipakai dalam pemrograman dan sistem terdistribusi. Masing-masing menyesuaikan kebutuhan urutan data, efisiensi memori, atau prioritas pemrosesan.

1. Linear Queue

• Prinsip Kerja: Elemen masuk di rear dan keluar di front. Indeks front/rear hanya bergerak maju.
• Kelebihan: Sederhana di implementasi cukup array atau linked-list.
• Keterbatasan: Saat rear mencapai ujung array, ruang di depan yang sudah kosong tidak terpakai (overflow palsu).
• Use-case: Antrian cetak (print spooler), antrean tugas sederhana.
  
  

2. Circular Queue

• Prinsip Kerja: Array diperlakukan melingkar setelah rear di ujung, ia “melingkar” kembali ke indeks 0 jika kosong.
• Kelebihan: Mengatasi ruang terbuang pada linear queue; enqueues/dequeues selalu O(1).
• Keterbatasan: Butuh logika modulo untuk front/rear; sedikit lebih rumit.
• Use-case: Buffer audio/video, ring buffer pada system real-time.

3. Priority Queue

• Prinsip Kerja: Setiap elemen punya “prioritas” bukan murni FIFO. Elemen dengan prioritas tertinggi (misal angka terkecil atau terbesar) di-dequeue dulu.
• Kelebihan: Fleksibel untuk scheduling di mana beberapa tugas perlu diprioritaskan.
• Keterbatasan: Operasi enqueue/dequeue bisa O(log n) jika diimplementasikan dengan heap.
• Use-case: Penjadwalan proses di sistem operasi, manajemen event di game engine.
  

4. Double-Ended Queue (Deque)

• Prinsip Kerja: Enqueue/dequeue dapat terjadi di kedua ujung (front atau rear).
• Kelebihan: Sangat fleksibel bertindak sebagai stack (LIFO) atau queue (FIFO) sesuai kebutuhan.
• Keterbatasan: Implementasi sedikit lebih kompleks; overhead pointer lebih banyak.
• Use-case: Undo/redo di aplikasi, sliding window pada algoritma, BFS bidirectional.

pilih Linear/Circular untuk antrian sederhana atau buffer, Priority Queue bila butuh pengurutan berdasar bobot, dan Deque jika perlu operasi di kedua ujung antrian. Dengan memahami karakteristik tiap tipe, Anda dapat mengimplementasikan queue yang paling sesuai performa dan fungsionalitas yang dibutuhkan.

Implementasi Queue di Berbagai Bahasa

Berikut contoh implementasi Queue baik menggunakan library bawaan maupun struktur manual di beberapa bahasa populer.

Python (collections.deque)

from collections import deque

# Inisialisasi queue
queue = deque()

# Enqueue
queue.append("A")
queue.append("B")
queue.append("C")

# Peek / Front
print("Front:", queue[0])   # Front: A

# Dequeue
item = queue.popleft()
print("Dequeued:", item)    # Dequeued: A

# isEmpty
print("Is empty?", len(queue) == 0)  # Is empty? False

Java (java.util.Queue)

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();

        // Enqueue
        queue.offer("A");
        queue.offer("B");
        queue.offer("C");

        // Peek / Front
        System.out.println("Front: " + queue.peek());  // Front: A

        // Dequeue
        String item = queue.poll();
        System.out.println("Dequeued: " + item);       // Dequeued: A

        // isEmpty
        System.out.println("Is empty? " + queue.isEmpty()); // Is empty? false
    }
}

JavaScript (Array)

class Queue {
  constructor() {
    this.items = [];
  }
  enqueue(el) { this.items.push(el); }
  dequeue() { return this.items.shift(); }
  peek() { return this.items[0]; }
  isEmpty() { return this.items.length === 0; }
}

const q = new Queue();
q.enqueue('A');
q.enqueue('B');
q.enqueue('C');

console.log('Front:', q.peek());       // Front: A
console.log('Dequeued:', q.dequeue()); // Dequeued: A
console.log('Is empty?', q.isEmpty()); // Is empty? false

C++ (std::queue)

#include <iostream>
#include <queue>
using namespace std;

int main() {
    queue<string> q;

    // Enqueue
    q.push("A");
    q.push("B");
    q.push("C");

    // Peek / Front
    cout << "Front: " << q.front() << endl;  // Front: A

    // Dequeue
    cout << "Dequeued: " << q.front() << endl;
    q.pop();                                 // Dequeued: A

    // isEmpty
    cout << "Is empty? " << boolalpha << q.empty() << endl; // Is empty? false

    return 0;
}

Contoh Penggunaan Queue

Berikut beberapa contoh nyata penggunaan Queue dalam pemrograman dan arsitektur sistem semuanya memanfaatkan sifat FIFO untuk menata aliran data atau tugas secara teratur.

1. Print Spooler

Pada sistem operasi, perintah cetak dikirim ke print spooler yang menempatkannya dalam queue. Printer akan mengambil job satu per satu sesuai urutan masuk, mencegah tumpang tindih dokumen.

User A → [Job1] → Printer  
User B → [Job1, Job2] → Printer proses Job1, lalu Job2 

2. Task Scheduling (Job Queue)

Worker background (misalnya Celery, Sidekiq) menaruh tugas–tugas berat (email, pemrosesan gambar) ke queue. Worker mengambil tugas terdepan, memproses, kemudian mengambil tugas berikutnya.

# Contoh Celery (Python)
// client
send_email.delay(user_id)
// worker
@app.task
def send_email(user_id): ...

3. Message Broker (RabbitMQ, Kafka)

Layanan mikros­ervice berkomunikasi lewat message queue. Producer men‐enqueue pesan, consumer men‐dequeue dan memprosesnya secara asinkron, menjamin loose coupling dan load leveling.

[Producer] → Queue "orders" → [Consumer A, Consumer B]

4. Breadth-First Search (BFS) pada Graf/Pohon

Algoritma BFS menggunakan queue untuk menelusuri simpul per level. Ketika satu simpul dikunjungi, semua tetangganya di-queue, lalu diproses berurutan.

q = deque([start])
while q:
    node = q.popleft()
    for neighbor in graph[node]:
        if not visited[neighbor]:
            visited[neighbor]=True
            q.append(neighbor)

5. Rate Limiting & Throttling

API gateway dapat menempatkan permintaan ke queue dan memproses maksimum N request per detik. Request lebih akan menunggu giliran, mencegah overload backend.

Keuntungan Struktur Data Queue

1. Operasi FIFO yang Konsisten
   Menjamin elemen diproses dalam urutan masuk (first-in, first-out), cocok untuk antrian tugas, scheduling, dan buffer.
2. Waktu Akses O(1)
   Enqueue (tambah) dan dequeue (ambil) dapat dilakukan dalam waktu konstan tanpa harus menggeser banyak elemen.
3. Kesederhanaan Implementasi
   Baik dengan array, linked-list, maupun library bawaan, konsep queue mudah dipahami dan diimplementasikan.
4. Mencegah Starvation
   Karena urutan terjamin, tidak ada elemen yang “terlewat” atau terus-menerus diabaikan; fairness terjaga.
5. Fleksibilitas Varian
   Tersedia varian circular queue untuk memaksimalkan ruang, priority queue untuk penjadwalan berbobot, dan deque untuk operasi di kedua ujung.
   

Keterbatasan Struktur Data Queue

1. Kapasitas Terbatas (pada Bounded Queue)
   Jika ukuran maksimum dicapai, enqueue baru akan gagal atau menunggu, memerlukan mekanisme penanganan overflow.
   
   
2. Tidak Cocok untuk Akses Acak
   Hanya front/rear yang dapat diakses langsung; mengambil elemen di tengah antrean memerlukan dequeue hingga elemen tersebut muncul.
   
   
3. Potensi Underflow
   Dequeue pada queue kosong harus dicegah dengan pengecekan isEmpty(), atau akan menimbulkan error.
   
   
4. Overhead Pointer (Linked-List)
   Implementasi linked-list menambah overhead memori untuk pointer next (dan prev pada deque), kurang efisien dibanding array pada data kecil.
   
   
5. Manajemen Memori (Array-Based)
   Linear queue bisa menyisakan ruang “kosong” di depan; circular queue mengatasi ini tapi menambah kompleksitas logika indeks.
   
   
6. Prioritas Tunggal
   Pada linear/circular queue biasa, semua elemen diperlakukan sama. Untuk kebutuhan prioritas, harus gunakan priority queue terpisah.

Perbedaan antara Stack dan Queue