Concurrency: Concepts

Concurrency vs Parallelism

Concurrency = About Structure

• Dealing with many tasks at once — not necessarily at the same time, but managing overlapping progress.

• Analogy: A single chef cooking multiple dishes by switching between them.

• Focuses on structure and interleaving.

Parallelism = About Execution

• Doing many tasks literally at the same time — requires multiple CPUs/cores.

• Analogy: Several chefs cooking different dishes simultaneously.

• Focuses on speed and simultaneous execution.

In Java terms:

• Concurrency = managing multiple threads or tasks.

• Parallelism = actually executing tasks simultaneously on multiple cores.

Example:

// Concurrency (may or may not run in parallel)

ExecutorService executor = Executors.newFixedThreadPool(2);

// Parallelism (explicitly using parallel processing)

Arrays.stream(data).parallel().forEach(...);

Synchronous vs Asynchronous

Synchronous

• Tasks happen one after another; caller waits for completion.

• Analogy: You stand in line and wait until the cashier finishes with the person in front of you.

• Simple, but may waste time waiting.

Asynchronous

• You start a task and continue doing other things while it runs.

• Analogy: You place an order and get notified when it’s ready.

• Improves responsiveness; often used with callbacks or futures.

In Java terms:

// Synchronous

String data = fetchData();   // blocks until done

// Asynchronous

CompletableFuture<String> data = CompletableFuture.supplyAsync(() -> fetchData());

// continues immediately

Blocking vs Non-Blocking

Blocking

• The thread waits until the task completes or resource is available.

• Consumes a thread while waiting.

Non-Blocking

• The thread doesn’t wait — continues doing other work.

• Enables scalability; good for I/O-heavy systems.

In Java terms:

// Blocking

int result = future.get();  // blocks

// Non-blocking

future.thenAccept(result -> System.out.println(result)); // callback

Concurrency + Asynchronous = Cooperative Progress

• Concurrency: multiple tasks progressing “together”

• Asynchronous: progress without waiting

• So, asynchronous concurrency = several tasks progressing independently without blocking each other → This is the foundation for high-performance, scalable applications (e.g., web servers, event loops).

Synchronous vs Asynchronous --vs-- Blocking vs Non-Blocking

=============================

      TASK-LEVEL MODEL

=============================

Synchronous Task   → Caller waits

Asynchronous Task  → Caller continues immediately

        │

        ▼

=============================

      THREAD-LEVEL MODEL

=============================

Blocking Operation     → Thread is parked (waiting)

Non-Blocking Operation → Thread continues or yields

        │

        ▼

=============================

      LOCK BEHAVIOR

=============================

Blocking Lock     → wait until acquired

Non-Blocking Lock → try and move on (CAS, tryLock)