How Java's Concurrency APIs Fit Together

Concurrency problems often arise from a simple need: let two independent operations progress without one waiting for the other to complete. While the concept is straightforward, selecting the appropriate Java concurrency API can be challenging, as there are numerous options that appear to address the same requirement. These APIs each serve distinct purposes, such as describing work, determining execution methods, representing results, protecting shared state, or coordinating tasks.

Organizing them by responsibility transforms the standard library from a list of names into a structured map. To illustrate this, we will use a small customer-dashboard example, then examine additional examples for scenarios beyond the dashboard's capabilities. The code examples assume basic Java knowledge, not prior concurrency experience.

Consider a scenario where an endpoint builds a customer dashboard from a profile and a list of recent orders:

```

var profile = loadProfile ();

var orders = loadOrders ();

return new Dashboard (profile, orders);

```

Initially, the code appears simple, but it involves three distinct responsibilities: describing each operation, deciding how to execute it, and obtaining the result. To address this, we need to explore seven questions that map to various Java concurrency APIs:

1. What work should happen?

2. Where and how should it run?

3. How do I obtain or combine results?

4. How do I protect shared state?

5. How do I share data safely?

6. How do tasks coordinate?

7. How do I divide computation?

These questions help identify the appropriate API for a given problem rather than treating them as rigid boxes for classifying every type. In practice, focus on tasks, executors, futures, and shared-state mechanisms. Later, you can learn about queues and semaphores for handoff and limits, and CyclicBarrier, fork/join, and continuation-scheduling rules as specialized solutions when needed.

A crucial distinction in this map is the difference between concurrent tasks and parallel work. Concurrency involves tasks making progress during overlapping periods, while parallel execution requires hardware resources to run work simultaneously. In our dashboard example, concurrency is used to handle waiting-heavy operations, while parallel computation will be explored in a separate data-processing example.

Tasks in Java represent work. A thread is one possible execution mechanism, with Runnable representing an operation with no result and Callable V returning a value that may throw an exception. Neither interface determines the thread that will execute the task. The distinction between describing work (Runnable, Callable) and executing it (Thread, Executor, ExecutorService) is crucial for designing concurrent applications.