Executor Framework

🏭 The Executor Framework: Your Personal Task Factory

Imagine you own a chocolate factory. Every day, hundreds of orders come in. You could try making each chocolate yourself, one at a time… but that would be exhausting! Instead, you hire workers, organize them into teams, and let them handle the orders while you manage everything from your office.

That’s exactly what the Executor Framework does in Java! Instead of creating and managing threads yourself, you get a ready-made factory that handles everything for you.

🎯 What You’ll Learn

graph TD
    A["Executor Framework"] --> B["Callable & Future"]
    A --> C["ExecutorService"]
    A --> D["Thread Pools"]
    A --> E["ThreadLocal"]
    B --> F["Tasks that return values"]
    C --> G["Managing worker threads"]
    D --> H["Reusing threads efficiently"]
    E --> I["Private data for each thread"]

🍫 Chapter 1: Callable and Future - Orders That Give You Something Back

The Problem with Runnable

Remember Runnable? It’s like telling a worker: “Go make chocolate!” But the worker just does it and walks away. You never find out if they succeeded or what they made!

// Runnable - no way to get result
Runnable task = () -> {
    System.out.println("Making chocolate...");
    // No return value! 😢
};

Enter Callable - The Smart Worker

Callable is like giving your worker a walkie-talkie. They do the work AND report back!

// Callable - returns a result!
Callable<String> task = () -> {
    Thread.sleep(2000);
    return "Dark Chocolate Ready! 🍫";
};

Key Difference:

Future - Your Receipt Ticket

When you submit a Callable, you get a Future - like a ticket at a bakery counter. You can:

• Check if it’s ready: isDone()
• Wait and get the result: get()
• Cancel the order: cancel()

// Submit task and get Future
Future<String> ticket = executor.submit(task);

// Do other things while waiting...
System.out.println("Doing other work...");

// Now get the result (waits if needed)
String chocolate = ticket.get();
System.out.println(chocolate);

Real-World Example

Callable<Integer> calculatePrice = () -> {
    // Pretend this is complex math
    return 50 * 3 + 10;
};

Future<Integer> priceFuture =
    executor.submit(calculatePrice);

// Get result with timeout
Integer price = priceFuture.get(
    5, TimeUnit.SECONDS
);
System.out.println("Total: quot; + price);

🏪 Chapter 2: ExecutorService - The Factory Manager

What Is It?

ExecutorService is your factory manager. It takes your tasks (workers’ orders) and assigns them to available threads. You don’t worry about creating threads - the manager handles it all!

Creating Your First Factory

// Create a factory with 4 workers
ExecutorService factory =
    Executors.newFixedThreadPool(4);

// Submit work
factory.submit(() -> {
    System.out.println("Worker busy!");
});

The Life Cycle

graph TD
    A["Create ExecutorService"] --> B["Submit Tasks"]
    B --> C["Tasks Execute"]
    C --> D["Shutdown"]
    D --> E["Wait for Completion"]
    E --> F["Factory Closed"]

Shutting Down Properly

Super Important! Always close your factory, or it runs forever!

// Gentle shutdown - finish current work
factory.shutdown();

// Wait up to 60 seconds
factory.awaitTermination(
    60, TimeUnit.SECONDS
);

// OR force shutdown immediately
factory.shutdownNow();

Key Methods Cheat Table

👥 Chapter 3: Thread Pools - Your Team of Workers

Why Pools?

Creating a new thread for every task is like hiring a new employee for every order, then firing them immediately after. Wasteful! Thread pools reuse workers.

Types of Thread Pools

graph TD
    A["Thread Pools"] --> B["Fixed Pool"]
    A --> C["Cached Pool"]
    A --> D["Single Thread"]
    A --> E["Scheduled Pool"]
    B --> B1["Fixed number of workers"]
    C --> C1["Grows and shrinks"]
    D --> D1["Only one worker"]
    E --> E1["Runs tasks later"]

1. Fixed Thread Pool

Best for: When you know exactly how many workers you need.

// 4 workers, no more, no less
ExecutorService pool =
    Executors.newFixedThreadPool(4);

Think of a small bakery with 4 ovens. No matter how many orders come in, only 4 can bake at once!

2. Cached Thread Pool

Best for: Many short tasks that come and go.

// Creates threads as needed
ExecutorService pool =
    Executors.newCachedThreadPool();

Like a food court - workers appear when busy, go home when slow.

3. Single Thread Executor

Best for: Tasks that must run one at a time, in order.

// Only 1 worker ever
ExecutorService pool =
    Executors.newSingleThreadExecutor();

Like a drive-through - one car at a time!

4. Scheduled Thread Pool

Best for: Tasks that run later or repeatedly.

ScheduledExecutorService pool =
    Executors.newScheduledThreadPool(2);

// Run after 5 seconds
pool.schedule(
    () -> System.out.println("Hello!"),
    5, TimeUnit.SECONDS
);

// Run every 10 seconds
pool.scheduleAtFixedRate(
    () -> System.out.println("Tick!"),
    0, 10, TimeUnit.SECONDS
);

Quick Comparison

🎒 Chapter 4: ThreadLocal - Every Worker’s Personal Locker

The Problem

Imagine all factory workers sharing ONE toolbox. Chaos! They’d constantly fight over the hammer.

ThreadLocal gives each thread its own personal copy of a variable.

Simple Example

// Each thread gets its own counter
ThreadLocal<Integer> counter =
    ThreadLocal.withInitial(() -> 0);

// In Thread A
counter.set(5);
System.out.println(counter.get()); // 5

// In Thread B (different thread!)
System.out.println(counter.get()); // 0

Thread A’s 5 doesn’t affect Thread B’s copy!

Real-World Use Case: User Session

public class UserContext {
    private static ThreadLocal<String>
        currentUser = new ThreadLocal<>();

    public static void setUser(String user) {
        currentUser.set(user);
    }

    public static String getUser() {
        return currentUser.get();
    }

    // IMPORTANT: Clean up!
    public static void clear() {
        currentUser.remove();
    }
}

graph TD
    A["Request from Alice"] --> B["Thread 1"]
    C["Request from Bob"] --> D["Thread 2"]
    B --> E["ThreadLocal: Alice"]
    D --> F["ThreadLocal: Bob"]
    E --> G["Process as Alice"]
    F --> H["Process as Bob"]

⚠️ The Golden Rule

Always call remove() when done!

If threads are reused (like in a pool), old data can leak to new tasks!

try {
    UserContext.setUser("Alice");
    // Do work...
} finally {
    UserContext.clear(); // ALWAYS!
}

🎮 Putting It All Together

Here’s a complete example combining everything:

public class ChocolateFactory {
    // Each worker tracks their own count
    static ThreadLocal<Integer>
        chocolatesMade =
            ThreadLocal.withInitial(() -> 0);

    public static void main(String[] args) {
        // Create factory with 3 workers
        ExecutorService factory =
            Executors.newFixedThreadPool(3);

        // Submit 5 orders
        List<Future<String>> orders =
            new ArrayList<>();

        for (int i = 1; i <= 5; i++) {
            int orderId = i;
            Future<String> order =
                factory.submit(() -> {
                    makeChocolate(orderId);
                    return "Order " + orderId;
                });
            orders.add(order);
        }

        // Collect all results
        for (Future<String> order : orders) {
            System.out.println(
                order.get() + " complete!"
            );
        }

        // Close factory
        factory.shutdown();
    }

    static void makeChocolate(int orderId) {
        try {
            int count = chocolatesMade.get();
            chocolatesMade.set(count + 1);
            Thread.sleep(1000);
            System.out.println(
                Thread.currentThread().getName()
                + " made chocolate #" + orderId
            );
        } finally {
            chocolatesMade.remove();
        }
    }
}

🚀 Key Takeaways

1. Callable + Future = Tasks that return values and can be tracked
2. ExecutorService = Your task manager that handles thread lifecycle
3. Thread Pools = Reuse threads instead of creating new ones
4. ThreadLocal = Private storage for each thread (remember to clean up!)

💡 Remember This!

“Don’t manage threads yourself - let the Executor Framework be your factory manager!”

The Executor Framework makes multithreading simple, safe, and efficient. Like having a professional factory manager who handles all the messy details while you focus on what matters! 🏭✨