Concurrency Utilities

🎭 Java Concurrency Utilities: The Restaurant Kitchen Story

Imagine you’re running the busiest restaurant in town. You have multiple chefs (threads) working together. How do you make sure they don’t bump into each other, steal each other’s ingredients, or create chaos? That’s exactly what Java’s Concurrency Utilities solve!

🍳 Our Story: The Magical Kitchen

Picture a kitchen with 10 chefs working at once. Each chef is a thread. The kitchen equipment, ingredients, and serving counter are shared resources. Without rules, it’s chaos! Java gives us magical tools to keep everything organized.

🔐 Concurrent Locks: The Special Kitchen Keys

What Are They?

Think of locks like special keys to different areas of the kitchen. Only the chef with the key can use that area.

The Old Way vs The New Way

// OLD WAY: synchronized (like a single key)
synchronized(pantry) {
    // Only one chef at a time
    takeSugar();
}

// NEW WAY: ReentrantLock (smart key)
Lock pantryLock = new ReentrantLock();
pantryLock.lock();
try {
    takeSugar();
} finally {
    pantryLock.unlock();
}

Why ReentrantLock is Better

ReadWriteLock: Reading Menu vs Writing Orders

ReadWriteLock menuLock = new ReentrantReadWriteLock();

// Many chefs can READ the menu together
menuLock.readLock().lock();
readTodaysSpecial();
menuLock.readLock().unlock();

// Only ONE chef can WRITE new items
menuLock.writeLock().lock();
addNewDish("Pasta");
menuLock.writeLock().unlock();

💡 Real Life: Multiple people can read a Google Doc together, but only one can edit at a time!

⚛️ Atomic Variables: The Magic Counters

The Problem

// DANGER! Two chefs counting orders
int orderCount = 0;
orderCount++;  // NOT safe with multiple chefs!

When Chef A and Chef B both try to add 1 at the same moment:

• Both read: 5
• Both add: 5 + 1 = 6
• Both write: 6
• Lost one order! Should be 7!

The Solution: Atomic Variables

AtomicInteger orderCount = new AtomicInteger(0);

// SAFE! Like a magic counter that
// can't be tricked
orderCount.incrementAndGet();  // Always correct!

Common Atomic Types

graph TD
    A["Atomic Variables"] --> B["AtomicInteger"]
    A --> C["AtomicLong"]
    A --> D["AtomicBoolean"]
    A --> E["AtomicReference"]
    B --> F["count.incrementAndGet#40;#41;"]
    C --> G["bigNum.addAndGet#40;100#41;"]
    D --> H["isOpen.compareAndSet#40;false, true#41;"]

Compare-And-Swap: The Secret Sauce

AtomicInteger stock = new AtomicInteger(10);

// "Only take sugar IF there are 10 bags"
boolean success = stock.compareAndSet(10, 9);
// Returns true only if it was exactly 10

🎯 Think of it like: “I’ll only buy this toy IF the price is still $10”

🚦 Synchronization Utilities: Traffic Lights for Threads

CountDownLatch: “Wait for Everyone!”

Like waiting for all chefs to arrive before opening:

CountDownLatch allChefsReady = new CountDownLatch(3);

// Each chef signals "I'm ready!"
allChefsReady.countDown();  // Chef 1
allChefsReady.countDown();  // Chef 2
allChefsReady.countDown();  // Chef 3

// Manager waits until all are ready
allChefsReady.await();
System.out.println("Kitchen is OPEN!");

CyclicBarrier: “Let’s All Start Together!”

Like a relay race where everyone must reach checkpoint:

CyclicBarrier roundComplete = new CyclicBarrier(4,
    () -> System.out.println("All dishes served!")
);

// Each chef waits at barrier
roundComplete.await();  // Waits until 4 chefs arrive

Semaphore: “Only 3 People in the Pantry!”

Semaphore pantryPasses = new Semaphore(3);

pantryPasses.acquire();  // Get a pass
// Enter pantry (max 3 chefs)
pantryPasses.release();  // Return pass

Comparison Chart

📦 BlockingQueue: The Order Window

What Is It?

Imagine a window between the kitchen and dining area. Chefs put finished dishes there. Waiters take dishes from there. If it’s full, chefs wait. If it’s empty, waiters wait.

graph LR
    A["👨‍🍳 Chef"] -->|put| B["📦 BlockingQueue"]
    B -->|take| C["🧑‍🍳 Waiter"]
    style B fill:#f9f,stroke:#333

Example Code

BlockingQueue<String> orderWindow =
    new ArrayBlockingQueue<>(10);

// Chef puts dish (waits if full)
orderWindow.put("🍕 Pizza");

// Waiter takes dish (waits if empty)
String dish = orderWindow.take();

Types of BlockingQueues

🍴 ForkJoinPool: Divide and Conquer

The Concept

Big task? Break it into smaller pieces! Like chopping a huge pile of vegetables:

graph TD
    A["🥕 Chop 1000 carrots"] --> B["🥕 Chop 500"]
    A --> C["🥕 Chop 500"]
    B --> D["🥕 250"]
    B --> E["🥕 250"]
    C --> F["🥕 250"]
    C --> G["🥕 250"]

Code Example

class ChopCarrots extends RecursiveTask<Integer> {
    int[] carrots;

    protected Integer compute() {
        if (carrots.length < 100) {
            return chopDirectly();  // Small enough!
        }
        // Split into two tasks
        ChopCarrots left = new ChopCarrots(firstHalf);
        ChopCarrots right = new ChopCarrots(secondHalf);

        left.fork();   // Start left in background
        int rightResult = right.compute();
        int leftResult = left.join();  // Wait for left

        return leftResult + rightResult;
    }
}

Work Stealing: The Smart Part

If Chef A finishes early, they steal tasks from Chef B’s queue!

🎯 Real Life: Like helping your sibling with their chores when you finish yours early!

🔮 CompletableFuture: Cooking Without Waiting

The Problem

Old way: Stand and wait for each dish to cook. New way: Start cooking, do other things, get notified when done!

Basic Usage

// Start making pizza (don't wait!)
CompletableFuture<String> pizza =
    CompletableFuture.supplyAsync(() -> {
        cookPizza();
        return "🍕 Hot Pizza!";
    });

// Do other stuff while pizza cooks...
prepSalad();

// Now get the pizza
String myPizza = pizza.get();

Chaining: Then Do This, Then That

CompletableFuture.supplyAsync(() -> "🥬 Lettuce")
    .thenApply(lettuce -> lettuce + " + 🍅")
    .thenApply(salad -> salad + " + 🧀")
    .thenAccept(finalSalad ->
        System.out.println("Made: " + finalSalad)
    );
// Output: Made: 🥬 Lettuce + 🍅 + 🧀

Combining Futures

CompletableFuture<String> burger = makeBurger();
CompletableFuture<String> fries = makeFries();

// Wait for BOTH
burger.thenCombine(fries, (b, f) ->
    "Combo: " + b + " with " + f
);

// Wait for EITHER (first one wins!)
burger.applyToEither(fries, first ->
    "First ready: " + first
);

⚠️ Race Condition: The Kitchen Nightmare

What Is It?

Two chefs reach for the last egg at the same time. Both think they got it. Chaos!

// DANGER: Race Condition!
if (eggs > 0) {          // Chef A: "There's 1 egg!"
                         // Chef B: "There's 1 egg!"
    eggs--;              // Chef A takes it
    useEgg();            // Chef B takes it too?!
}                        // eggs = -1 😱

The Fix: Proper Synchronization

synchronized(eggBasket) {
    if (eggs > 0) {
        eggs--;
        useEgg();
    }
}

Or Use Atomic Variables

AtomicInteger eggs = new AtomicInteger(5);

// Safe! Only one can succeed
if (eggs.decrementAndGet() >= 0) {
    useEgg();
} else {
    eggs.incrementAndGet();  // Oops, put it back
}

Signs of Race Conditions

• 🚨 Results change randomly
• 🚨 Works sometimes, fails sometimes
• 🚨 Fails more under heavy load
• 🚨 Hard to reproduce bugs

🦋 Virtual Threads: Lightweight Chefs (Java 21+)

The Old Problem

Regular threads are like hiring full-time chefs. Expensive! You can only have a few hundred.

The New Solution

Virtual threads are like having thousands of part-time helpers!

// OLD: Limited to ~thousands
Thread chef = new Thread(() -> cookDish());

// NEW: Millions possible!
Thread virtualChef = Thread.ofVirtual()
    .start(() -> cookDish());

Creating Many Virtual Threads

// Create 10,000 virtual threads easily!
try (var executor = Executors
        .newVirtualThreadPerTaskExecutor()) {

    for (int i = 0; i < 10_000; i++) {
        executor.submit(() -> {
            handleCustomerOrder();
        });
    }
}

When to Use Virtual Threads

graph TD
    A{Task Type?} -->|CPU Heavy| B["Regular Threads"]
    A -->|Waiting/IO| C["Virtual Threads ✨"]
    B --> D["Math calculations"]
    B --> E["Video processing"]
    C --> F["Database calls"]
    C --> G["API requests"]
    C --> H["File reading"]

Key Difference

🎯 Quick Summary: Which Tool When?

🏆 You Did It!

You now understand how Java keeps multiple threads working together without chaos! Just like a well-organized kitchen, with the right tools, even thousands of “chefs” can work in harmony.

“Concurrency is not about making things faster. It’s about making things possible.”

🎉 Now go build something amazing!