This document discusses threads and concurrency in Node.js. It defines concurrency vs parallelism, and describes how Node.js uses a single-threaded event loop with non-blocking I/O to achieve scalability. It also introduces Node.js worker threads for offloading CPU-intensive tasks, and how they can communicate and share memory with the main thread using message passing and shared array buffers. The structured clone algorithm used during message passing is also briefly explained.

1. Threads and Node.js
Sakthipriyan Vairamani
Node.js Technical Steering Committee Member

2. Concurrency vs Parallelism
● Parallelism
○ Multiple execution units
○ Simultaneous execution
● Concurrency
○ Single execution unit
○ Time interleaved execution

3. Concurrency vs Parallelism
No concurrency, no parallelism
1 2 3 1 2 3 1 2 3
CPU Cycles
CPU 1
Concurrency, no parallelism
1 1 1 2 2 2 3 3 3
CPU Cycles
CPU 1
No concurrency, parallelism
1 2 3
1 2 3
1 2 3
CPU Cycles
CPU 1
CPU 2
CPU 3
Concurrency, parallelism
1 2 3
1 2 3
1 2 3
CPU Cycles
CPU 1
CPU 2
CPU 3

4. Execution Models
● Single tasking
○ One program, runs to completion
● Multi tasking
○ Co-operative
○ Pre-emptive
○ Multi Core

5. Process
● An instance of a program
○ Just like how objects are to classes
● Container for
○ Code
○ Memory (Stack, Heap, Data segment)
○ Resource Descriptors
○ State (Execution Context)

6. Process
Code Resource Descriptors Heap
Execution Context (Stack + Registers)
Main Thread

7. Thread
● Execution Context
○ Registers
○ Stack
● Associated with a process
● Share process’s resources and memory
● Can be multiple for a process

8. Thread
Code, Resources, and Heap
Context
Main Thread
Context Context
Thread 1 Thread 2

9. Node.js
● Single threaded
● Non-blocking IO
● Async APIs with callbacks
● Scalable
● Never block Node.js’s main thread

10. Node.js’s Asynchronicity and Threads
Event Loop
libuv
Thread PoolNode.js APIs
Userland JavaScript code
1
2
3

11. Node.js Worker Threads
● CPU Intensive Tasks
● Share main process’s resources, but not variables
● Can Share SharedArrayBuffer
● Message Passing
● Structured Cloning

12. Creating Worker Threads
// DO NOT RUN THIS
const { Worker } = require('worker_threads');
const w = new Worker(__filename);

13. Detect Main & Worker Threads
const { isMainThread, Worker } = require('worker_threads');
if (isMainThread) {
console.log('Inside Main Thread');
const w = new Worker(__filename);
} else {
console.log('Inside Worker Thread');
}

14. Pass initial context during Thread Creation
if (isMainThread) {
const w = new Worker(__filename, {
workerData: {
data: 'Node.js'
}
});
} else {
console.log(require('worker_threads').workerData);
}

15. Communication between Main and Worker Threads
const { isMainThread, parentPort, Worker } =
require('worker_threads');
if (isMainThread) {
const w = new Worker(__filename);
w.postMessage('Ping');
w.once('message', console.log);
w.on('exit', (exitCode) => console.log(exitCode));
} else {
parentPort.once('message', function (msg) {
if (msg === 'Ping') parentPort.postMessage('Pong');
});
}

16. Sharing Memory Between Threads
const i32Array = new Int32Array(new SharedArrayBuffer(12));
if (isMainThread) {
console.log(i32Array); // Int32Array [ 0, 0, 0 ]
const w = new Worker(__filename, {
workerData: i32Array
});
w.once('message', () => console.log(i32Array)); // Int32Array [ 1, 0, 0 ]
} else {
const data = require('worker_threads').workerData;
data[0] = 1;
parentPort.postMessage('Done');
}

17. ● Atomic operations on SharedArrayBuffers
● Bunch of static functions
○ Atomics.store(sab, index, value)
○ Atomics.load(sab, index)
○ Atomics.add(sab, index, value)
○ ...
Atomics

18. Atomics and Mutable Shared Arrays
const i32Array = new Int32Array(new SharedArrayBuffer(12));
if (isMainThread) {
console.log(i32Array); // Int32Array [ 0, 0, 0 ]
const w = new Worker(__filename, {
workerData: i32Array
});
w.once('message', () => console.log(Atomics.load(i32Array, 0))); // 1
} else {
const data = require('worker_threads').workerData;
data[0] = 1;
parentPort.postMessage('Done');
}

19. Terminating Worker Threads
if (isMainThread) {
const w = new Worker(__filename);
console.log(w.threadId); // 1
w.postMessage(w.threadId);
w.once('message', (id) => {
console.log('Thread ID is', id);
w.terminate();
});
w.on('exit', console.log); // 0
} else {
parentPort.once('message', (msg) => {
let i = 0;
while (true) {
if (i++ === 10) {
parentPort.postMessage(require('worker_threads').threadId);
break; // Uncomment to change exit code
}

20. The Structured Clone Algorithm
● Clone/copy of the object
● Used during postMessage
● Error and Function cannot be cloned
● Property Descriptors, Setters, and Getters are ignored
● Prototype chain is ignored

21. Thank you!
Sakthipriyan Vairamani
Node.js Technical Steering Committee Member