Concurrency Utilities

Advanced ~25 min read

Creating and managing threads manually is difficult and error-prone. The Executor Framework (introduced in Java 5) separates task creation from execution.

ExecutorService

Instead of new Thread(task).start(), you use an Executor to run tasks.

ExecutorService executor = Executors.newFixedThreadPool(10);
executor.execute(new RunnableTask());
executor.shutdown();

Thread Pools

Creating a new thread is expensive. A Thread Pool reuses a fixed number of threads to execute many tasks.

newFixedThreadPool(n): Reuses a fixed set of threads.
newCachedThreadPool(): Creates new threads as needed, but reuses them if available.

Callable vs Runnable

Runnable doesn't return a value. Callable does!

Future<Integer> future = executor.submit(callableTask);
Integer result = future.get(); // Blocks until result is ready

Full Example

We will create a pool of 2 threads to execute 5 tasks.

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class WorkerThread implements Runnable {
    private String message;

public WorkerThread(String s) {
        this.message = s;
    }

public void run() {
        System.out.println(Thread.currentThread().getName() + " (Start) message = " + message);
        processMessage();
        System.out.println(Thread.currentThread().getName() + " (End)");
    }

private void processMessage() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class ExecutorExample {
    public static void main(String[] args) {

// 1. Create a pool of 2 threads
        ExecutorService executor = Executors.newFixedThreadPool(2);

// 2. Submit 5 tasks
        for (int i = 0; i < 5; i++) {
            Runnable worker = new WorkerThread("" + i);
            executor.execute(worker);
        }

// 3. Shutdown
        executor.shutdown();

try {
            // Wait for all tasks to finish
            while (!executor.awaitTermination(24L, TimeUnit.HOURS)) {
                System.out.println("Still waiting...");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("\nFinished all threads");
    }
}

Output

Click Run to execute your code

Summary

Use ExecutorService instead of managing threads manually.
Use Callable if you need a result from the thread.
Always call shutdown() to stop the executor.

Previous Synchronization

Next Enums →

ExecutorService

Thread Pools

Callable vs Runnable

Full Example

Summary

Enjoying these tutorials?