Process and print jobs in a Queue in order

One of the key characteristics of a queue is the First-In-First-Out (FIFO) principle. This means that the first item added to the queue will be the first one to be processed or removed. This concept is particularly relevant in the context of print queues, where the first job added to the queue should be the first one to be printed.

In a print queue, when a user sends a print job, it is added to the queue. The printer then processes the jobs in the order they were added, ensuring that the first job submitted is the first one to be printed. This FIFO behavior ensures fairness and maintains the order of the print jobs, preventing any job from being skipped or prioritized over others. This also ensures that the pages order is maintained.

Now, let’s look at a sample program that demonstrates the implementation of a print queue using the FIFO principle:


import queue

# Create a print queue to which print jobs can be added
print_queue = queue.Queue()

def add_to_print_queue(job):
  """
  Function to add a new job to the print queue.
  """
  print_queue.put(job)
  print(f"Added '{job}' to the print queue.")

def print_jobs():
  """
  Function to process all the jobs in the print queue.
  """
  while not print_queue.empty():
    job = print_queue.get()
    print(f"Printing '{job}'.")

# Add some jobs to the print queue
add_to_print_queue("Document 1")
add_to_print_queue("Document 2")
add_to_print_queue("Document 3")

# Print all the jobs in the print queue
print_jobs()


#include <iostream>
#include <queue>

// Create a print queue to which print jobs can be added
std::queue<std::string> print_queue;

// Function to add a new job to the print queue
void add_to_print_queue(std::string job) {
  print_queue.push(job);
  std::cout << "Added '" << job << "' to the print queue." << std::endl;
}

// Function to process all the jobs in the print queue
void print_jobs() {
  while (!print_queue.empty()) {
    std::string job = print_queue.front();
    print_queue.pop();
    std::cout << "Printing '" << job << "'." << std::endl;
  }
}

int main() {
  // Add some jobs to the print queue
  add_to_print_queue("Document 1");
  add_to_print_queue("Document 2");
  add_to_print_queue("Document 3");

  // Print all the jobs in the print queue
  print_jobs();

  return 0;
}


// Create a print queue to which print jobs can be added
class PrintQueue {
  constructor() {
    this.queue = [];
  }

  // Function to add a new job to the print queue
  addToPrintQueue(job) {
    this.queue.push(job);
    console.log(`Added '${job}' to the print queue.`);
  }

  // Function to process all the jobs in the print queue
  printJobs() {
    while (this.queue.length > 0) {
      const job = this.queue.shift();
      console.log(`Printing '${job}'.`);
    }
  }
}

// Create a new print queue
const printQueue = new PrintQueue();

// Add some jobs to the print queue
printQueue.addToPrintQueue("Document 1");
printQueue.addToPrintQueue("Document 2");
printQueue.addToPrintQueue("Document 3");

// Print all the jobs in the print queue
printQueue.printJobs();


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

public class Main {
  public static void main(String[] args) {
    // Create a print queue to which print jobs can be added
    Queue<String> printQueue = new LinkedList<>();

    // Function to add a new job to the print queue
    addToPrintQueue("Document 1");
    addToPrintQueue("Document 2");
    addToPrintQueue("Document 3");

    // Function to process all the jobs in the print queue
    printJobs();
  }

  public static void addToPrintQueue(String job) {
    // Function to add a new job to the print queue
    printQueue.offer(job);
    System.out.println("Added '" + job + "' to the print queue.");
  }

  public static void printJobs() {
    // Function to process all the jobs in the print queue
    while (!printQueue.isEmpty()) {
      String job = printQueue.poll();
      System.out.println("Printing '" + job + "'.");
    }
  }
}

In this example, the add_to_print_queue function allows users to add new jobs to the queue, and the print_jobs function processes all the jobs present in the print_queue in the order they were added (FIFO).

When you run this program, the output will be:

Added 'Document 1' to the print queue.
Added 'Document 2' to the print queue.
Added 'Document 3' to the print queue.
Printing 'Document 1'.
Printing 'Document 2'.
Printing 'Document 3'.

Notice that the jobs are printed in the order they were added to the print queue, demonstrating the FIFO principle in action.

Although this is a really simple example, this helps understanding the syntax and basic usage of Queue data structures in different programming languages. TODO: In the upcoming articles, we’ll take a look at more complicated examples where jobs are added and removed from the queue concurrently from different threads.