SharedArrayBuffer for shared memory in Node.js - Step-by-Step Execution

Concept Flow - SharedArrayBuffer for shared memory

Create SharedArrayBuffer

↓

Create TypedArray view on buffer

↓

Pass buffer to worker threads

↓

Workers read/write shared memory

↓

Use Atomics for sync

↓

Main thread and workers see updated data

This flow shows how a shared memory buffer is created, accessed by multiple threads, and synchronized using Atomics.

Execution Sample

Node.js

const sab = new SharedArrayBuffer(4);
const arr = new Int32Array(sab);
arr[0] = 42;
// Worker reads arr[0] and updates it
// Main thread sees updated value

Creates a shared buffer, writes a value, and allows worker threads to read and update it.

Execution Table

Step	Action	Buffer Content (arr[0])	Notes
1	Create SharedArrayBuffer of 4 bytes	undefined	Buffer allocated, no data yet
2	Create Int32Array view on buffer	undefined	TypedArray view created, no data set
3	Set arr[0] = 42	42	Main thread writes initial value
4	Worker reads arr[0]	42	Worker sees initial value
5	Worker updates arr[0] = 100 using Atomics.store	100	Worker writes new value atomically
6	Main thread reads arr[0] using Atomics.load	100	Main thread sees updated value

💡 Execution stops after main thread reads updated shared value

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
sab (SharedArrayBuffer)	Allocated (4 bytes)	Allocated (4 bytes)	Allocated (4 bytes)	Allocated (4 bytes)
arr[0]	undefined	42	100	100

Key Moments - 3 Insights

Why do we need Atomics to update shared memory?

Without Atomics, simultaneous writes can cause race conditions. Atomics ensure updates are done safely and visible to all threads, as shown in steps 5 and 6.

Can we use normal arrays instead of SharedArrayBuffer for sharing data?

No, normal arrays are not shared between threads. SharedArrayBuffer creates memory accessible by multiple threads, as in step 1.

Why do we create a TypedArray view on the SharedArrayBuffer?

SharedArrayBuffer is raw memory. TypedArray like Int32Array interprets this memory as numbers, allowing us to read/write values, shown in step 2.

Visual Quiz - 3 Questions

Look at the execution table, what is the value of arr[0] after step 3?

A undefined

B 100

C 42

D 0

💡 Hint

Check the 'Buffer Content (arr[0])' column at step 3 in the execution table.

At which step does the worker update the shared memory?

A Step 5

B Step 4

C Step 2

D Step 6

💡 Hint

Look for the step where 'Worker updates arr[0]' in the Action column.

If we skip using Atomics in step 5, what might happen?

A The update is still safe and visible immediately

B Race conditions may occur causing inconsistent data

C The buffer size will increase automatically

D The main thread will crash

💡 Hint

Refer to the key moment about why Atomics are needed for safe updates.

Concept Snapshot

SharedArrayBuffer creates memory shared across threads.
Use TypedArray views (e.g., Int32Array) to read/write data.
Pass the buffer to workers to share data.
Use Atomics methods to safely read/write and synchronize.
Without Atomics, data races can cause errors.
Main and workers see the same memory updates.

Full Transcript

SharedArrayBuffer allows multiple threads in Node.js to share memory safely. First, a SharedArrayBuffer is created with a fixed size in bytes. Then, a TypedArray view like Int32Array is created on top of this buffer to read and write numbers. This buffer is passed to worker threads, which can read and update the shared memory. To avoid conflicts and ensure visibility, Atomics methods are used for reading and writing. This way, all threads see consistent data. The example code shows creating a buffer, writing a value, a worker updating it atomically, and the main thread reading the updated value. This process enables efficient shared memory communication between threads.