LESSON 9.1

The JS event loop vs Java threads

Understand the fundamental concurrency models: JavaScript's single-threaded event loop and asynchronous I/O versus Java's multi-threaded OS threads and memory model.

6 min read

Concurrency is the art of handling multiple tasks at the same time. However, JavaScript and Java approached concurrency with radically different mental models. Understanding when to use event loops, async/await, worker pools, and memory barriers is critical for designing high-performance low-level systems.

The problem

snippet.js

1 // The JS trap: blocking the single thread blocks EVERYTHING
2 app.get("/compute", (req, res) => {
3   // 5-second synchronous loop:
4   const hash = crypto.pbkdf2Sync("pass", "salt", 10000000, 64, "sha512");
5   res.send(hash); // While this runs, NO OTHER REQUEST CAN BE SERVED!
6 });

JavaScript · 6 lines

UTF-8

Snippet.java

1 // The Java trap: uncapped OS thread creation exhausts RAM
2 for (int i = 0; i < 100_000; i++) {
3   new Thread(() -> handleRequest()).start();
4   // OutOfMemoryError: unable to create native thread (1MB stack per thread!)
5 }

Java · 5 lines

UTF-8

The models compared

Dimension	JavaScript (V8 / Node)	Java (JVM)
Execution Model	Single main thread + Event Loop	Multi-threaded (Platform / Virtual threads)
Shared State	No shared memory by default; shared memory only via `SharedArrayBuffer`	Shared heap memory across threads with Java Memory Model (JMM)
Synchronization	Run-to-completion semantics for synchronous turns	Mutexes (`synchronized`, `ReentrantLock`), atomics, volatiles
I/O Model	Non-blocking asynchronous I/O (libuv)	Blocking I/O or non-blocking (NIO), Virtual threads

Laying out the diagram…

JS Event Loop: synchronous code runs to completion. Microtasks (Promises) run before macrotasks (Timers, I/O).

In code

When to choose which model

Use the Event Loop model when:

Your application is heavily I/O-bound (web APIs, proxy servers, chat services).
You want to avoid lock contention, deadlocks, and race conditions over shared heap state.

Use Multi-Threaded Java when:

Your workloads are CPU-intensive (cryptography, video transcoding, machine learning, physics engines).
You need fine-grained multi-core parallel processing over shared in-memory data structures.

Where you have already seen it

Node.js, Deno, and Bun power web backends via single-threaded event loops. The browser UI uses an event loop to render frames and handle clicks without multithreading bugs. In enterprise software, high-throughput financial trading systems (e.g. LMAX Disruptor) use pinned Java threads to process millions of transactions per second.

Event Loop vs Producer-Consumer: Producer-consumer queues can be implemented across OS threads (Java) or across event loop ticks (JS queues).
Event Loop and Reactor Pattern: The event loop is a concrete implementation of the Reactor architectural pattern.

Quick check

Why does synchronous file reading (fs.readFileSync) harm production Node.js servers?

Try it

Cooperative Async Task Group LLD

Implement a structured task group that runs tasks concurrently and aborts remaining tasks on first error.

Check your understanding

1.JavaScript is single-threaded, yet Node.js can handle tens of thousands of concurrent network connections. How is this possible?
2.What happens in Node.js when a function performs heavy CPU-bound computation (e.g. calculating Fibonacci for 5 seconds)?
3.How do Java's virtual threads (Project Loom, Java 21+) compare to traditional Java platform threads?

Practice it

Fair Async Semaphore LLDCoordinate asynchronous work with FIFO permits, cancellation and single-use release handles.Cooperative Async Task Group LLDOwn bounded child tasks, request cancellation on failure and join every started child.

Your notes

9. Concurrency patterns

LESSON 9.1

The JS event loop vs Java threads

Understand the fundamental concurrency models: JavaScript's single-threaded event loop and asynchronous I/O versus Java's multi-threaded OS threads and memory model.

6 min read

The problem

snippet.js

1 // The JS trap: blocking the single thread blocks EVERYTHING
2 app.get("/compute", (req, res) => {
3   // 5-second synchronous loop:
4   const hash = crypto.pbkdf2Sync("pass", "salt", 10000000, 64, "sha512");
5   res.send(hash); // While this runs, NO OTHER REQUEST CAN BE SERVED!
6 });

JavaScript · 6 lines

UTF-8

Snippet.java

1 // The Java trap: uncapped OS thread creation exhausts RAM
2 for (int i = 0; i < 100_000; i++) {
3   new Thread(() -> handleRequest()).start();
4   // OutOfMemoryError: unable to create native thread (1MB stack per thread!)
5 }

Java · 5 lines

UTF-8

The models compared

Dimension	JavaScript (V8 / Node)	Java (JVM)
Execution Model	Single main thread + Event Loop	Multi-threaded (Platform / Virtual threads)
Shared State	No shared memory by default; shared memory only via `SharedArrayBuffer`	Shared heap memory across threads with Java Memory Model (JMM)
Synchronization	Run-to-completion semantics for synchronous turns	Mutexes (`synchronized`, `ReentrantLock`), atomics, volatiles
I/O Model	Non-blocking asynchronous I/O (libuv)	Blocking I/O or non-blocking (NIO), Virtual threads

Laying out the diagram…

JS Event Loop: synchronous code runs to completion. Microtasks (Promises) run before macrotasks (Timers, I/O).

In code

When to choose which model

Use the Event Loop model when:

Your application is heavily I/O-bound (web APIs, proxy servers, chat services).
You want to avoid lock contention, deadlocks, and race conditions over shared heap state.

Use Multi-Threaded Java when:

Your workloads are CPU-intensive (cryptography, video transcoding, machine learning, physics engines).
You need fine-grained multi-core parallel processing over shared in-memory data structures.

Where you have already seen it

Event Loop vs Producer-Consumer: Producer-consumer queues can be implemented across OS threads (Java) or across event loop ticks (JS queues).
Event Loop and Reactor Pattern: The event loop is a concrete implementation of the Reactor architectural pattern.

Quick check

Why does synchronous file reading (fs.readFileSync) harm production Node.js servers?

Try it

Cooperative Async Task Group LLD

Implement a structured task group that runs tasks concurrently and aborts remaining tasks on first error.

Check your understanding

1.JavaScript is single-threaded, yet Node.js can handle tens of thousands of concurrent network connections. How is this possible?
2.What happens in Node.js when a function performs heavy CPU-bound computation (e.g. calculating Fibonacci for 5 seconds)?
3.How do Java's virtual threads (Project Loom, Java 21+) compare to traditional Java platform threads?

Practice it

Your notes

1 // JavaScript concurrency: non-blocking async operations & worker simulation 2 class AsyncWorker { 3 // Non-blocking asynchronous task 4 async fetchRemoteData(id) { 5 // Simulating I/O delay without blocking the CPU thread 6 await new Promise((resolve) => setTimeout(resolve, 10)); 7 return `Data for ${id}`; 8 } 9 10 // Running concurrent tasks with Promise.all 11 async runConcurrentBatch(ids) { 12 const promises = ids.map((id) => this.fetchRemoteData(id)); 13 return Promise.all(promises); 14 } 15 } 16 17 // Execution demonstration 18 const worker = new AsyncWorker(); 19 worker.runConcurrentBatch(["req-1", "req-2", "req-3"]).then((results) => { 20 console.assert(results.length === 3); 21 console.log("Async results:", results); 22 }); 23 24 // Demonstrating run-to-completion: this executes before the setTimeout promises resolve! 25 console.log("Main thread continues executing synchronously...");

1 public class Example { 2 static final class WorkerPool { 3 private final java.util.concurrent.ExecutorService executor = 4 java.util.concurrent.Executors.newFixedThreadPool(2); 5 6 public java.util.concurrent.CompletableFuture<String> fetchRemoteData(String id) { 7 return java.util.concurrent.CompletableFuture.supplyAsync(() -> { 8 try { 9 Thread.sleep(10); 10 } catch (InterruptedException e) { 11 Thread.currentThread().interrupt(); 12 } 13 return "Data for " + id; 14 }, executor); 15 } 16 17 public void shutdown() { executor.shutdown(); } 18 } 19 20 public static void main(String[] args) throws Exception { 21 var pool = new WorkerPool(); 22 var f1 = pool.fetchRemoteData("req-1"); 23 var f2 = pool.fetchRemoteData("req-2"); 24 25 var combined = java.util.concurrent.CompletableFuture.allOf(f1, f2); 26 combined.join(); 27 28 if (!"Data for req-1".equals(f1.get()) || !"Data for req-2".equals(f2.get())) { 29 throw new AssertionError(); 30 } 31 System.out.println("Java futures completed: " + f1.get() + ", " + f2.get()); 32 pool.shutdown(); 33 } 34 }

The problem

The models compared

In code

When to choose which model

Where you have already seen it

Related patterns

Check your understanding

Practice it

The problem

The models compared

In code

When to choose which model

Where you have already seen it

Related patterns

Check your understanding

Practice it