Spooling in OS Explained — How Computers Handle Slow Devices Smartly

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * SpoolQueueDemo.java
 *
 * Simulates the core mechanic of OS spooling:
 *   - A fast 'application' thread produces print jobs quickly
 *   - A slow 'printer' thread consumes them at device speed
 *   - A shared BlockingQueue acts as the spool (disk buffer)
 *
 * This mirrors exactly how the OS print spooler works:
 * applications write to the queue and return immediately,
 * while the printer daemon drains it independently.
 */
public class SpoolQueueDemo {

    // The spool buffer — in a real OS this lives on disk.
    // Capacity 5 simulates a bounded spool directory.
    private static final LinkedBlockingQueue<String> spoolQueue =
            new LinkedBlockingQueue<>(5);

    public static void main(String[] args) throws InterruptedException {

        // --- PRODUCER: simulates an application sending print jobs ---
        Thread applicationThread = new Thread(() -> {
            String[] documents = {
                "Invoice_April.pdf",
                "MeetingNotes.docx",
                "SalesReport_Q1.xlsx",
                "EmployeeHandbook.pdf",
                "ProjectPlan.pptx"
            };

            for (String document : documents) {
                try {
                    // The app 'submits' a print job — this is near-instant.
                    // put() will block ONLY if the spool queue is full (back-pressure).
                    spoolQueue.put(document);
                    System.out.println("[APP]     Spooled: " + document +
                            "  (queue size: " + spoolQueue.size() + ")");

                    // Application moves on immediately — no waiting for printer.
                    // Simulating the user doing other work between prints.
                    Thread.sleep(200); // 200ms between submissions
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("[APP]     All jobs submitted. Application is free!");
        }, "Application-Thread");

        // --- CONSUMER: simulates the OS printer spooler daemon ---
        Thread printerDaemon = new Thread(() -> {
            int jobsProcessed = 0;
            while (jobsProcessed < 5) {
                try {
                    // poll() waits up to 3 seconds for a job before timing out.
                    // This mirrors a real daemon that wakes when new jobs arrive.
                    String job = spoolQueue.poll(3, TimeUnit.SECONDS);

                    if (job != null) {
                        System.out.println("[PRINTER] Printing: " + job + " ...");
                        // Printer is SLOW — takes 800ms per job.
                        // Application is not affected by this delay at all.
                        Thread.sleep(800);
                        System.out.println("[PRINTER] Done:     " + job);
                        jobsProcessed++;
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("[PRINTER] Spool queue empty. Printer idle.");
        }, "Printer-Daemon");

        // Daemon threads die when the main program exits —
        // just like real OS spooler processes.
        printerDaemon.setDaemon(true);

        printerDaemon.start(); // Start printer daemon first (it waits for jobs)
        applicationThread.start();

        applicationThread.join();  // Wait for all jobs to be submitted
        printerDaemon.join();      // Wait for all jobs to be printed

        System.out.println("\n[SYSTEM]  Spooling demo complete.");
    }
}

/**
 * BufferingVsSpooling.java
 *
 * Demonstrates the structural difference between:
 *   - BUFFERING: RAM-based, in-process, one producer writes then one consumer reads
 *   - SPOOLING:  Disk-based, cross-process, multiple producers, daemon consumer
 *
 * This is a conceptual demonstration — not a full I/O implementation.
 */
public class BufferingVsSpooling {

    // ============================================================
    // BUFFERING: A simple in-memory circular buffer.
    // Producer fills it; consumer drains it.
    // If the buffer is full, the producer MUST wait.
    // ============================================================
    static class PrintBuffer {
        private final byte[] memoryBuffer;
        private int writePosition = 0;
        private int readPosition  = 0;
        private int occupiedBytes = 0;

        PrintBuffer(int capacityBytes) {
            // Buffer lives entirely in RAM — small and fast
            this.memoryBuffer = new byte[capacityBytes];
            System.out.println("[BUFFER]  Created in-RAM buffer, capacity: "
                    + capacityBytes + " bytes");
        }

        // Returns false if buffer is full — producer must block or back off
        synchronized boolean write(byte dataByte) {
            if (occupiedBytes == memoryBuffer.length) {
                return false; // Buffer full — producer is BLOCKED
            }
            memoryBuffer[writePosition] = dataByte;
            writePosition = (writePosition + 1) % memoryBuffer.length;
            occupiedBytes++;
            return true;
        }

        synchronized int read() {
            if (occupiedBytes == 0) return -1; // Nothing to read
            byte data = memoryBuffer[readPosition];
            readPosition = (readPosition + 1) % memoryBuffer.length;
            occupiedBytes--;
            return data;
        }

        int getOccupied() { return occupiedBytes; }
    }

    // ============================================================
    // SPOOLING: Simulated as a named file on disk.
    // Any number of producers can append jobs.
    // Consumer (daemon) reads independently, even after producers exit.
    // ============================================================
    static class PrintSpooler {
        private final java.util.Queue<String> spoolDirectory;
        private final String spoolPath;

        PrintSpooler(String spoolDirectory) {
            // In a real OS: /var/spool/cups (Linux) or C:\Windows\System32\spool (Windows)
            this.spoolPath = spoolDirectory;
            this.spoolDirectory = new java.util.LinkedList<>();
            System.out.println("[SPOOLER] Spool directory ready at: " + spoolPath);
        }

        // Multiple callers can spool simultaneously — jobs persist until printed
        synchronized void spoolJob(String producerName, String documentName) {
            String spoolEntry = producerName + ":" + documentName
                    + ":" + System.currentTimeMillis();
            spoolDirectory.offer(spoolEntry);
            // In a real OS, this writes a file to disk and returns immediately.
            System.out.println("[SPOOLER] Job added by " + producerName
                    + " -> " + documentName
                    + " (" + spoolDirectory.size() + " jobs pending)");
        }

        // Daemon calls this — drains jobs one at a time
        synchronized String getNextJob() {
            return spoolDirectory.poll();
        }

        int getPendingCount() { return spoolDirectory.size(); }
    }

    public static void main(String[] args) throws InterruptedException {
        System.out.println("=== BUFFERING DEMO ===");
        PrintBuffer buffer = new PrintBuffer(4); // Tiny 4-byte buffer

        // Producer writes 3 bytes — succeeds
        System.out.println("Write byte A: " + buffer.write((byte) 'A'));
        System.out.println("Write byte B: " + buffer.write((byte) 'B'));
        System.out.println("Write byte C: " + buffer.write((byte) 'C'));
        System.out.println("Write byte D: " + buffer.write((byte) 'D'));
        // Buffer is full — 5th write FAILS (producer must wait in a real system)
        System.out.println("Write byte E (buffer full): " + buffer.write((byte) 'E'));
        System.out.println("Buffer occupied: " + buffer.getOccupied() + "/4 bytes");

        System.out.println("\n=== SPOOLING DEMO ===");
        PrintSpooler spooler = new PrintSpooler("/var/spool/myprinter");

        // Multiple independent producers — none of them block each other
        spooler.spoolJob("Alice", "Presentation.pptx");
        spooler.spoolJob("Bob",   "TaxReturn.pdf");
        spooler.spoolJob("Alice", "Backup_Report.docx"); // Alice submits again
        spooler.spoolJob("Carol", "LabResults.pdf");

        System.out.println("\n[DAEMON]  Printer daemon waking up, draining spool...");
        String job;
        while ((job = spooler.getNextJob()) != null) {
            System.out.println("[DAEMON]  Processing: " + job);
            Thread.sleep(100); // Simulate slow printing
        }
        System.out.println("[DAEMON]  Spool empty. All jobs printed.");
    }
}

import java.util.PriorityQueue;
import java.util.Comparator;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * PrioritySpooler.java
 *
 * Models a realistic OS spool scheduler that supports job priorities.
 * Lower priority number = higher urgency (like OS process scheduling).
 *
 * This is how CUPS and Windows Print Spooler actually handle
 * situations where multiple jobs compete for one printer.
 */
public class PrioritySpooler {

    // Represents a single spooled print job
    static class PrintJob implements Comparable<PrintJob> {
        private static final AtomicInteger jobCounter = new AtomicInteger(1);

        final int    jobId;           // Unique ID assigned by spooler
        final String ownerUsername;   // Who submitted this job
        final String documentName;    // The actual document
        final int    priorityLevel;   // 1 = urgent, 5 = low priority
        final long   submittedAtMs;   // Timestamp for FIFO within same priority

        PrintJob(String owner, String document, int priority) {
            this.jobId          = jobCounter.getAndIncrement();
            this.ownerUsername  = owner;
            this.documentName   = document;
            this.priorityLevel  = priority;
            this.submittedAtMs  = System.currentTimeMillis();
        }

        // Jobs with lower priority number print first.
        // If priority is equal, earlier submission wins (FIFO).
        @Override
        public int compareTo(PrintJob other) {
            if (this.priorityLevel != other.priorityLevel) {
                return Integer.compare(this.priorityLevel, other.priorityLevel);
            }
            return Long.compare(this.submittedAtMs, other.submittedAtMs);
        }

        @Override
        public String toString() {
            return String.format("Job#%02d [P%d] %-10s -> %s",
                    jobId, priorityLevel, ownerUsername, documentName);
        }
    }

    // The spooler maintains a priority queue — exactly like a real OS scheduler
    private final PriorityQueue<PrintJob> spoolQueue =
            new PriorityQueue<>();

    // Adds a job to the spool directory (disk write in a real OS)
    public void submitJob(String owner, String document, int priority) {
        PrintJob job = new PrintJob(owner, document, priority);
        spoolQueue.offer(job);
        System.out.printf("[SUBMIT]  %s%n", job);
    }

    // Simulates the printer daemon draining jobs in priority order
    public void drainAndPrint() throws InterruptedException {
        System.out.println("\n[DAEMON]  Printer daemon starting — processing spool queue...");
        System.out.println("[DAEMON]  " + spoolQueue.size() + " jobs in queue.\n");

        while (!spoolQueue.isEmpty()) {
            PrintJob nextJob = spoolQueue.poll(); // Always returns highest-priority job
            System.out.printf("[PRINT]   Processing %s%n", nextJob);
            Thread.sleep(300); // Simulate print time
            System.out.printf("[DONE]    Finished   %s%n%n", nextJob);
        }
        System.out.println("[DAEMON]  Spool queue empty. Printer going idle.");
    }

    public static void main(String[] args) throws InterruptedException {
        PrioritySpooler spooler = new PrioritySpooler();

        // Multiple users submit jobs — all at roughly the same time
        System.out.println("=== JOBS BEING SUBMITTED TO SPOOL ===");
        spooler.submitJob("bob",   "FinancialReport.xlsx",  3); // Normal
        spooler.submitJob("alice", "BoardPresentation.pptx", 1); // URGENT
        spooler.submitJob("carol", "LunchMenu.docx",         5); // Low priority
        spooler.submitJob("admin", "SecurityPolicy.pdf",     1); // Also urgent
        spooler.submitJob("bob",   "MeetingAgenda.docx",     2); // High priority

        // Now the daemon processes them — order depends on priority, not submission order
        spooler.drainAndPrint();
    }
}