Discover how queues power the systems around us: from graph algorithms like BFS to task scheduling, buffer management, and network protocols. See FIFO in action across computer science and everyday technology.

Learning Objectives

BFS Algorithm

Level-by-level graph traversal

Task Scheduling

Fair resource allocation

Buffer Management

Data flow control

System Design

Real-world implementations

Breadth-First Search (BFS)

BFS explores a graph level by level, visiting all neighbors of a node before moving to the next level. This systematic approach relies on a queue to maintain the order of exploration.

BFS Algorithm Steps:

Start with initial node in queue

Dequeue a node and mark as visited

Add all unvisited neighbors to queue

Repeat until queue is empty

Why Use a Queue?

• FIFO ensures level-order: Nodes added first are processed first

• Guarantees shortest path: In unweighted graphs

• Systematic exploration: Never misses a closer node

• Memory efficient: Only stores current level + next level

BFS Applications:

• Shortest path in unweighted graphs

• Connected components detection

• Social network analysis (degrees of separation)

• Web crawling and sitemap generation

• GPS navigation systems

Interactive BFS Simulation

Step 1 of 7

Start with node A in queue

Queue: [A]

Visited: []

BFS Code Template:

function bfs(graph, start) {

const queue = [start];

const visited = new Set();

while (queue.length > 0) {

const node = queue.shift();

if (!visited.has(node)) {

visited.add(node);

// Process node

queue.push(...neighbors);

}

Task Scheduling & Process Management

Operating systems use queues to manage processes and ensure fair resource allocation. Tasks are scheduled in FIFO order, with different priority levels handled by separate queues.

CPU Scheduling Types:

First-Come, First-Served (FCFS)Simple Queue

Round RobinCircular Queue

Priority SchedulingPriority Queue

Multi-level QueueMultiple Queues

Queue Benefits in Scheduling:

• Fairness: First-come, first-served principle

• Predictability: Known order of execution

• Starvation Prevention: Every task gets a turn

• Easy Implementation: Simple data structure

Task Scheduling Simulation

Current Execution

CPU

High Priority Task

Ready Queue (FIFO):

Task A

Task B

Task C

High priority task preempts current queue

Round Robin Example:

Time Quantum: 4ms

Task A: 10ms → [4ms] → back to queue with 6ms remaining

Task B: 6ms → [4ms] → back to queue with 2ms remaining

Task C: 8ms → [4ms] → back to queue with 4ms remaining

Real-World Examples:

• Print job scheduling

• Download queue management

• Batch processing systems

• Request handling in web servers

Buffer Management & Data Streaming

Buffers use queues to manage data flow between systems with different processing speeds. They smooth out temporary speed mismatches and prevent data loss.

Buffer Applications:

I/O Buffering: Keyboard input, file reading

Network Buffering: Packet transmission, streaming

Print Spooling: Document queue management

Producer-Consumer: Multi-threaded systems

Buffer Types:

Single Buffer

One queue, simple implementation

Double Buffer

Two queues, one filling while other empties

Circular Buffer

Fixed size, efficient memory usage

Streaming Buffer Visualization

Video Streaming Buffer:

Producer

Generates data

Buffer Queue:

Frame1

Frame2

Frame3

Frame4

Frame5

Empty

↑ Front (Consumer reads)↑ Rear (Producer writes)

Processes data

Consumer

Producer-Consumer Code:

// Producer

while (producing) {

data = generateData();

buffer.enqueue(data);

}

// Consumer

while (consuming) {

data = buffer.dequeue();

processData(data);

}

Benefits:

• Smooth playback despite network fluctuations

• Prevents data loss during speed mismatches

• Allows asynchronous processing

• Improves overall system performance

Real-World Queue Systems

Queues are everywhere in technology and daily life. From the apps on your phone to massive data centers, FIFO principles ensure fair, organized, and efficient processing.

Web Services

Request Processing

Web servers queue incoming HTTP requests

API Rate Limiting

Queue requests to prevent system overload

Message Queues

RabbitMQ, Apache Kafka for microservices

Gaming & Entertainment

Matchmaking

Players queued by skill level and wait time

Event Processing

Game actions processed in order received

Content Delivery

Video streaming, music playlist management

Financial Systems

Transaction Processing

Banking transactions processed in order

Trading Systems

Stock orders queued by timestamp

Payment Processing

Credit card transactions in FIFO order

Transportation

Traffic Management

Traffic lights use queues for fair timing

Airport Systems

Flight queues for takeoff and landing

Ride Sharing

Driver-rider matching algorithms

Communication

Email Systems

Messages queued for delivery

Chat Applications

Message ordering in group chats

Call Centers

Customer calls handled in order

Healthcare

Patient Management

Appointment scheduling and queuing

Emergency Triage

Priority queues for urgent cases

Lab Processing

Test samples processed in order

Queue Systems by the Numbers

1.7B

Website requests processed daily using queue systems

99.9%

Financial transaction accuracy with proper queuing

23ms

Average queue processing time in modern systems

10M+

Messages handled by messaging systems per second

Previous: Queue Types Next: Stacks vs Queues