Typed Arrays and Shared Memory

Use shared memory buffers to pass data between execution contexts without costly copies.

In this lesson, you will learn how to use SharedArrayBuffer to let different execution contexts access the exact same memory space simultaneously, eliminating the need to copy data back and forth.

The Problem with Copying

Usually, when you pass data between different parts of a program or across threads, Node.js creates a "copy." If you have a massive dataset, creating these duplicates wastes precious CPU time and clutters your memory, forcing the Garbage Collector to work overtime. Imagine if two chefs were cooking the same meal but insisted on having two separate fridges, constantly moving ingredients between them—it would be incredibly inefficient.

Typed Arrays as a Window

Before we share memory, we need to understand Typed Arrays. JavaScript's standard arrays are flexible but slow because they hold arbitrary objects. Typed Arrays (like Uint8Array or Int32Array) act as a structured "view" over a fixed block of raw binary data. They tell Node.js exactly how to interpret the bytes in that memory (e.g., "treat these 4 bytes as one 32-bit integer").

Shared Memory

A SharedArrayBuffer is a special type of buffer that lives outside the standard garbage-collected heap. When you wrap a SharedArrayBuffer in a Typed Array, any change you make to that array is instantly visible to any other thread or context that is also looking at that same buffer.

Here is a simplified look at how this works:

// Create a buffer that holds 1024 bytes of shared memory
const sharedBuffer = new SharedArrayBuffer(1024);

// Create a view to read/write those bytes as 32-bit integers
const sharedArray = new Int32Array(sharedBuffer);

// Writing to this array updates the raw memory immediately
sharedArray[0] = 42;

Because both contexts are pointing at the exact same physical memory address, there is no "copying" phase. The data doesn't move; the "window" into the data is simply shared. This is a powerful technique for high-performance Node.js applications, such as image processing or real-time data analysis, where keeping the memory footprint stable is critical for maintaining high throughput.

Key Takeaway: Shared memory allows multiple execution contexts to operate on the same raw data simultaneously without the overhead of duplicating the memory content.