Kurs NestJS · Moduł 8: Cache i wydajność
Memory Management - optymalizacja magazynów kastrum
W tej lekcji5
Zarządco magazynów! Konsul Caesar.js zauważył, że nasz fort jest przeciążony: po tygodniu pracy proces zajmuje dwa razy więcej pamięci niż po starcie, a legion ma coraz mniej miejsca na manewry. W końcu kontener dostaje limit pamięci i ginie w środku dnia. Czas nauczyć się zarządzania pamięcią w Node.js.
Czym jest zarządzanie pamięcią w świecie legionariuszy?
Wyobraź sobie aplikację jako system magazynów:
- heap - główny magazyn, gdzie przechowywane są tributy (obiekty),
- stack - formacja, w której tymczasowo stoją wywołania funkcji i ich zmienne lokalne,
- garbage collector - oddział sprzątający przedmioty, do których nikt już nie sięga,
- memory leaks - tributy, o których zapomniano, ale wciąż ktoś trzyma do nich klucz.
Dobre zarządzanie pamięcią to sprawny, szybki fort.
Monitoring pamięci
process.memoryUsage() zwraca pięć liczb: rss to cała pamięć procesu, heapTotal - zarezerwowana sterta, heapUsed - jej zajęta część, external - pamięć obiektów C++ powiązanych z JavaScriptem, a arrayBuffers - bufory. Serwis monitorujący próbkuje je co 10 sekund:
// memory-monitor.service.ts
import { Injectable } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';
import { getHeapStatistics } from 'node:v8';
@Injectable()
export class MemoryMonitorService {
private memoryHistory: Array<{
timestamp: Date;
usage: NodeJS.MemoryUsage;
}> = [];
private readonly MEMORY_THRESHOLD_MB = 512; // Alert przy 512MB
private readonly HISTORY_SIZE = 100;
// Prawdziwy limit sterty: domyślny albo z flagi --max-old-space-size
private readonly HEAP_LIMIT = getHeapStatistics().heap_size_limit;
@Cron('*/10 * * * * *') // Co 10 sekund
checkMemoryUsage(): void {
const usage = process.memoryUsage();
this.memoryHistory.push({ timestamp: new Date(), usage });
// Zachowaj tylko ostatnie 100 pomiarów
if (this.memoryHistory.length > this.HISTORY_SIZE) {
this.memoryHistory.shift();
}
// Sprawdź czy pamięć nie przekracza progu
const heapUsedMB = usage.heapUsed / 1024 / 1024;
if (heapUsedMB > this.MEMORY_THRESHOLD_MB) {
console.warn(`Wysokie użycie pamięci: ${heapUsedMB.toFixed(2)}MB`);
this.suggestOptimizations(usage);
}
// Loguj co minutę
if (new Date().getSeconds() === 0) {
this.logMemoryStatus(usage);
}
}@Cron wymaga ScheduleModule.forRoot(). Prawdziwy limit sterty podaje getHeapStatistics() z node:v8: heapTotal to tylko bieżąca rezerwacja, którą V8 sam powiększa, więc pierwsza wersja, porównując z nią, alarmowała przy zupełnie zdrowym procesie.
Co minutę serwis wypisuje stan i liczy trend:
private logMemoryStatus(usage: NodeJS.MemoryUsage): void {
const formatMB = (bytes: number) => (bytes / 1024 / 1024).toFixed(2);
console.log('Status magazynów kastrum:');
console.log(`Heap używany: ${formatMB(usage.heapUsed)}MB`);
console.log(`Heap całkowity: ${formatMB(usage.heapTotal)}MB`);
console.log(`RSS (pamięć fizyczna): ${formatMB(usage.rss)}MB`);
console.log(`Zewnętrzna: ${formatMB(usage.external)}MB`);
// Oblicz wzrost pamięci
const growthInfo = this.calculateMemoryGrowth();
if (growthInfo.isGrowing) {
console.log(`Trend: +${growthInfo.growthRate.toFixed(2)}MB/min`);
}
}
private calculateMemoryGrowth(): { isGrowing: boolean; growthRate: number } {
if (this.memoryHistory.length < 10) return { isGrowing: false, growthRate: 0 };
const recent = this.memoryHistory.slice(-10);
const oldest = recent[0];
const newest = recent[recent.length - 1];
const timeDiffMin = (newest.timestamp.getTime() - oldest.timestamp.getTime()) / 60000;
const memoryDiffMB = (newest.usage.heapUsed - oldest.usage.heapUsed) / 1024 / 1024;
const growthRate = memoryDiffMB / timeDiffMin;
return {
isGrowing: growthRate > 1, // Więcej niż 1MB/min
growthRate,
};
}Trend porównuje najstarszy i najnowszy z dziesięciu ostatnich pomiarów. Wzrost o ponad 1 MB na minutę, który nie spada, to pierwszy objaw wycieku.
Sugestie i alerty sprawdzają te same progi:
private suggestOptimizations(usage: NodeJS.MemoryUsage): void {
console.log('Sugestie optymalizacji:');
if (usage.heapUsed / this.HEAP_LIMIT > 0.9) {
console.log(' - Sterta blisko limitu: zrób heap snapshot i szukaj wycieku');
}
if (usage.external > 50 * 1024 * 1024) {
console.log(' - Sprawdź bufory i strumienie - może za dużo danych w pamięci');
}
console.log(" - Sprawdź potencjalne memory leaks w cache'ach");
console.log(' - Rozważ zmniejszenie TTL dla danych tymczasowych');
}
getMemoryReport() {
const current = process.memoryUsage();
const formatMB = (bytes: number) => (bytes / 1024 / 1024).toFixed(2);
return {
current: {
heapUsed: formatMB(current.heapUsed) + 'MB',
heapTotal: formatMB(current.heapTotal) + 'MB',
heapLimit: formatMB(this.HEAP_LIMIT) + 'MB',
rss: formatMB(current.rss) + 'MB',
external: formatMB(current.external) + 'MB',
},
trend: this.calculateMemoryGrowth(),
history: this.memoryHistory.slice(-20), // Ostatnie 20 pomiarów
alerts: this.generateAlerts(current),
};
}
private generateAlerts(usage: NodeJS.MemoryUsage): string[] {
const alerts = [];
const heapUsedMB = usage.heapUsed / 1024 / 1024;
if (heapUsedMB > this.MEMORY_THRESHOLD_MB) {
alerts.push(`Wysokie użycie heap: ${heapUsedMB.toFixed(2)}MB`);
}
if (usage.heapUsed / this.HEAP_LIMIT > 0.85) {
alerts.push('Sterta zajmuje ponad 85% limitu - grozi błąd out of memory');
}
const growthInfo = this.calculateMemoryGrowth();
if (growthInfo.isGrowing && growthInfo.growthRate > 5) {
alerts.push(`Szybki wzrost pamięci: ${growthInfo.growthRate.toFixed(2)}MB/min`);
}
return alerts;
}Stara wersja radziła tu „uruchom global.gc()”. To zła rada: V8 sprząta sam, a ręczne GC tylko zatrzymuje aplikację. Pełne sprzątanie ma jedno uczciwe zastosowanie - diagnostykę:
// Diagnostyka: czy pamięć wraca po pełnym GC? (wymaga flagi --expose-gc)
forceGarbageCollection(): { before: number; after: number; freed: number } {
const beforeMB = process.memoryUsage().heapUsed / 1024 / 1024;
if (global.gc) {
global.gc();
const afterMB = process.memoryUsage().heapUsed / 1024 / 1024;
const freedMB = beforeMB - afterMB;
console.log(`Garbage collection: zwolniono ${freedMB.toFixed(2)}MB`);
return {
before: beforeMB,
after: afterMB,
freed: freedMB,
};
} else {
console.warn('Garbage collection niedostępny - uruchom z flagą --expose-gc');
return { before: beforeMB, after: beforeMB, freed: 0 };
}
}
}Jeśli po wymuszonym GC pamięć nie spada, obiekty wciąż ktoś trzyma, czyli masz wyciek. Flagę --expose-gc włączaj tylko przy takim śledztwie.
Event loop - jedna droga przez obóz
JavaScript w Node.js działa w jednym wątku, który obsługuje zdarzenia w pętli. Dokumentacja Node.js wymienia jej fazy w tej kolejności: timers (setTimeout, setInterval), pending callbacks (odroczone wywołania I/O, dawniej nazywane I/O callbacks), idle i prepare, poll (nowe zdarzenia I/O), check (setImmediate) i close callbacks. Gdy jedna funkcja liczy synchronicznie przez sekundę, event loop jest zablokowany i zatrzymuje obsługę wszystkich innych żądań.
Opóźnienie pętli mierzy monitorEventLoopDelay() z perf_hooks, który zbiera pomiary w histogram:
// event-loop.monitor.ts
import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
import { Interval } from '@nestjs/schedule';
import { monitorEventLoopDelay } from 'node:perf_hooks';
@Injectable()
export class EventLoopMonitor implements OnModuleDestroy {
private readonly logger = new Logger(EventLoopMonitor.name);
private readonly histogram = monitorEventLoopDelay({ resolution: 20 });
constructor() {
this.histogram.enable();
}
@Interval(10000) // Co 10 sekund
check() {
const p99 = this.histogram.percentile(99) / 1e6; // nanosekundy na milisekundy
if (p99 > 100) {
this.logger.warn(`Event loop opóźniony: p99 = ${p99.toFixed(1)} ms`);
}
this.histogram.reset();
}
onModuleDestroy() {
this.histogram.disable();
}
}Histogram podaje wartości w nanosekundach, stąd dzielenie przez 1e6. W teście 200 ms blokady dało p99 równe 208 ms.
Techniki unikania blokowania, od najprostszej:
- async/await zamiast operacji synchronicznych, np.
fs.promiseszamiastreadFileSync, - przeniesienie ciężkich obliczeń do kolejki Bull (dziś BullMQ) obsługiwanej przez osobny proces,
- worker threads z
node:worker_threadsdla zadań obciążających CPU, - clustering z PM2, czyli kilka procesów na kilku rdzeniach.
Wycieki - tributy, o których zapomniano
Najczęstszą przyczyną wycieku są niezwolnione referencje: listener dodany przy każdym żądaniu i nigdy nieusunięty, domknięcie trzymające duży obiekt, rosnąca bez końca mapa albo zapomniany timer. Diagnoza idzie krokami:
- monitoruj rosnące zużycie pamięci (
process.memoryUsage), - wykonaj heap dump i przeanalizuj retencję obiektów,
- zidentyfikuj niezwolnione referencje i listenery,
- napraw wyciek i zweryfikuj stabilność pamięci.
Analiza heap dumpa pokazuje, które obiekty zajmują pamięć i kto je trzyma; narzędzia do zrzutów poznasz w lekcji o profilowaniu.
Optymalizacja cache'a i kolekcji
Klasyczny wyciek to cache bez limitu. Nasz ma limit liczby elementów i pamięci:
// memory-optimized-cache.service.ts
import { Injectable } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';
@Injectable()
export class MemoryOptimizedCacheService {
private cache = new Map<string, {
data: any;
timestamp: number;
accessCount: number;
lastAccess: number;
size: number;
timer: NodeJS.Timeout;
}>();
private maxSize = 1000; // Maksymalna liczba elementów
private maxMemoryMB = 100; // Maksymalna pamięć cache'a
private currentMemoryBytes = 0;
set(key: string, value: any, ttl: number = 300000): void {
const size = this.estimateSize(value);
// Usuń stary element jeśli istnieje - razem z jego timerem
this.delete(key);
// Zwalniaj miejsce, dopóki nowy element się nie zmieści
while (this.cache.size > 0 && (this.cache.size >= this.maxSize ||
(this.currentMemoryBytes + size) > this.maxMemoryMB * 1024 * 1024)) {
this.evictOldest();
}
// Ustaw TTL; unref() nie trzyma procesu przy życiu
const timer = setTimeout(() => this.delete(key), ttl);
timer.unref();
this.cache.set(key, {
data: value,
timestamp: Date.now(),
accessCount: 0,
lastAccess: Date.now(),
size,
timer,
});
this.currentMemoryBytes += size;
}
get(key: string): any {
const item = this.cache.get(key);
if (!item) return null;
// Aktualizuj statystyki dostępu
item.accessCount++;
item.lastAccess = Date.now();
return item.data;
}
delete(key: string): boolean {
const item = this.cache.get(key);
if (item) {
clearTimeout(item.timer);
this.currentMemoryBytes -= item.size;
return this.cache.delete(key);
}
return false;
}To wersja poprawiona. Pierwsza tworzyła nowy timer przy każdym set(), nie kasując starego - stary odpalał później i usuwał świeżą wartość. delete() czyści teraz timer, a unref() sprawia, że czekający timer nie blokuje zamknięcia procesu. Pętla while zwalnia tyle miejsca, ile trzeba, a nie jeden element.
Strategię eksmisji dobiera stan pamięci:
// Eksmisja według różnych strategii
private evictOldest(): void {
if (this.cache.size === 0) return;
const strategy = this.getEvictionStrategy();
switch (strategy) {
case 'LRU': // Least Recently Used
this.evictLRU();
break;
case 'LFU': // Least Frequently Used
this.evictLFU();
break;
case 'SIZE': // Największe elementy pierwsze
this.evictLargest();
break;
default:
this.evictOldestByTime();
}
}
private getEvictionStrategy(): string {
// Inteligentny wybór strategii na podstawie stanu pamięci
const memoryPressure = this.currentMemoryBytes / (this.maxMemoryMB * 1024 * 1024);
if (memoryPressure > 0.9) {
return 'SIZE'; // Pod wysokim ciśnieniem pamięci - usuń duże elementy
} else if (this.cache.size > this.maxSize * 0.8) {
return 'LRU'; // Dużo elementów - usuń najdawniej używane
} else {
return 'LFU'; // Normalnie - usuń najmniej popularne
}
}Pod presją pamięci usuwamy największe elementy, przy dużej liczbie - najdawniej używane (LRU), a normalnie - najrzadziej używane (LFU).
Cztery strategie różnią się tylko kryterium:
private evictLRU(): void {
let oldestKey = '';
let oldestTime = Infinity;
this.cache.forEach((item, key) => {
if (item.lastAccess < oldestTime) {
oldestTime = item.lastAccess;
oldestKey = key;
}
});
if (oldestKey) {
console.log(`LRU eviction: ${oldestKey}`);
this.delete(oldestKey);
}
}
private evictLFU(): void {
let leastUsedKey = '';
let leastUsedCount = Infinity;
this.cache.forEach((item, key) => {
if (item.accessCount < leastUsedCount) {
leastUsedCount = item.accessCount;
leastUsedKey = key;
}
});
if (leastUsedKey) {
console.log(`LFU eviction: ${leastUsedKey}`);
this.delete(leastUsedKey);
}
}
private evictLargest(): void {
let largestKey = '';
let largestSize = 0;
this.cache.forEach((item, key) => {
if (item.size > largestSize) {
largestSize = item.size;
largestKey = key;
}
});
if (largestKey) {
console.log(`SIZE eviction: ${largestKey} (${largestSize} bytes)`);
this.delete(largestKey);
}
}
private evictOldestByTime(): void {
let oldestKey = '';
let oldestTime = Infinity;
this.cache.forEach((item, key) => {
if (item.timestamp < oldestTime) {
oldestTime = item.timestamp;
oldestKey = key;
}
});
if (oldestKey) {
console.log(`TIME eviction: ${oldestKey}`);
this.delete(oldestKey);
}
}Poszukiwania startują od Infinity. Pierwsza wersja zaczynała od Date.now(), więc elementy dodane w tej samej milisekundzie nigdy nie były starsze i nic nie znikało: w teście cache z limitem 3 urósł do 10 elementów.
Na koniec szacowanie rozmiaru, statystyki i sprzątanie:
private estimateSize(obj: any): number {
// Przybliżone obliczenie rozmiaru obiektu w pamięci
const jsonString = JSON.stringify(obj);
return jsonString.length * 2; // UTF-16 = 2 bytes per character
}
getStats() {
const memoryUsageMB = this.currentMemoryBytes / 1024 / 1024;
const avgItemSize = this.cache.size > 0 ? this.currentMemoryBytes / this.cache.size : 0;
let totalAccesses = 0;
this.cache.forEach(item => {
totalAccesses += item.accessCount;
});
return {
size: this.cache.size,
maxSize: this.maxSize,
memoryUsageMB: memoryUsageMB.toFixed(2),
maxMemoryMB: this.maxMemoryMB,
avgItemSize: Math.round(avgItemSize),
totalAccesses,
fillRatio: (this.cache.size / this.maxSize * 100).toFixed(1) + '%',
memoryRatio: (memoryUsageMB / this.maxMemoryMB * 100).toFixed(1) + '%',
};
}
// Czyszczenie przeterminowanych elementów
@Cron('0 */5 * * * *') // Co 5 minut (pierwsze pole to sekundy)
cleanupExpired(): void {
const now = Date.now();
const toDelete = [];
this.cache.forEach((item, key) => {
// Usuń elementy starsze niż godzina bez dostępu
if (now - item.lastAccess > 3600000) {
toDelete.push(key);
}
});
toDelete.forEach(key => {
this.delete(key);
});
if (toDelete.length > 0) {
console.log(`Wyczyszczono ${toDelete.length} przestarzałych elementów cache'a`);
}
}
}JSON.stringify daje tylko zgrubny rozmiar, bo obiekt w pamięci zajmuje inaczej niż jego tekst. Wzorzec 0 */5 * * * * znaczy co 5 minut; stary */5 * * * * * odpalał się co 5 sekund, bo pierwsze pole to sekundy.
Polecam Ci gotową bibliotekę lru-cache albo prosty trik z edytora obok: Map pamięta kolejność wstawiania, więc najstarszy wpis usuniesz w stałym czasie. Własny cache pisz tylko po to, żeby zrozumieć mechanizm. W następnej lekcji ograniczymy ruch, zanim zaleje magazyny.
Pamiętaj: w dobrze prowadzonym magazynie każdy tribut ma datę przydatności i miejsce na półce, a nie leży zapomniany w kącie.
Kod do tej lekcji: src/memory-management.ts
// Memory Management - Optymalizacja Magazynow Kohorty
import { Injectable, Logger } from '@nestjs/common';
// 1. Monitoring pamieci
@Injectable()
export class MemoryMonitor {
private readonly logger = new Logger('MemoryMonitor');
getMemoryUsage() {
const usage = process.memoryUsage();
return {
rss: Math.round(usage.rss / 1024 / 1024), // MB
heapTotal: Math.round(usage.heapTotal / 1024 / 1024),
heapUsed: Math.round(usage.heapUsed / 1024 / 1024),
external: Math.round(usage.external / 1024 / 1024),
heapPercent: Math.round(
(usage.heapUsed / usage.heapTotal) * 100
),
};
}
// Sprawdz czy pamiec jest w normie
checkHealth(thresholdMB: number = 512): {
healthy: boolean;
message: string;
} {
const mem = this.getMemoryUsage();
const healthy = mem.heapUsed < thresholdMB;
return {
healthy,
message: healthy
? `Memory OK: ${mem.heapUsed}MB / ${thresholdMB}MB`
: `WARNING: ${mem.heapUsed}MB exceeds ${thresholdMB}MB!`,
};
}
}
// 2. Unikanie wyciekow pamieci
// ZLE - wyciek pamieci (tablica rosnie bez konca):
// class BadService {
// private cache: any[] = [];
// addToCache(data: any) {
// this.cache.push(data); // NIGDY nie czyszczone!
// }
// }
// DOBRZE - cache z limitem:
class BoundedCache<T> {
private items: Map<string, { data: T; addedAt: number }> = new Map();
private maxSize: number;
private ttlMs: number;
constructor(maxSize = 1000, ttlMs = 300000) {
this.maxSize = maxSize;
this.ttlMs = ttlMs;
}
set(key: string, data: T) {
// Usun najstarsze jesli za duzo
if (this.items.size >= this.maxSize) {
const oldest = this.items.keys().next().value;
this.items.delete(oldest);
}
this.items.set(key, { data, addedAt: Date.now() });
}
get(key: string): T | null {
const item = this.items.get(key);
if (!item) return null;
// Sprawdz TTL
if (Date.now() - item.addedAt > this.ttlMs) {
this.items.delete(key);
return null;
}
return item.data;
}
get size() { return this.items.size; }
}
// 3. Garbage Collector
// Node.js automatycznie zarzadza pamiecia (GC)
// Ale mozesz wymuszic: global.gc() (z flaga --expose-gc)
// 4. Streams zamiast ladowania calych plikow do pamieci
// ZLE: const data = fs.readFileSync('huge-file.csv');
// DOBRZE: const stream = fs.createReadStream('huge-file.csv');
// 5. WeakMap dla tymczasowych danych
// const cache = new WeakMap();
// Obiekty w WeakMap moga byc garbage collected!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Event loop blocking w Node.js powoduje:
2. Worker threads w Node.js najlepiej używać do:
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Napisz serwis monitorujący opóźnienia event loop i logujący ostrzeżenia
- Układanie w pionie
Uporządkuj fazy event loop Node.js:
- Klikanie w kolejności
Ułóż techniki unikania blokowania event loop od najprostszej:
- Edytor kodu
Napisz serwis zbierający metryki pamięci (heapUsed, rss, external)
- Układanie w pionie
Uporządkuj kroki diagnostyki memory leak:
- Układanie w pionie
Ułóż warstwy cache'owania od najbliższej użytkownikowi:
Zadania po tej lekcji
- PytanieEvent loop blocking
- PytanieWorker threads w Node.js
- Zadanie z kodemPraktyka: Monitoring event loop
- Ułóż w kolejnościFazy event loop Node.js
- Kliknij w kolejnościTechniki unikania blokowania
- PytanieHeap dump analysis
- PytanieWykrywanie memory leaks
- Zadanie z kodemPraktyka: Memory monitoring
- Ułóż w kolejnościProces debugowania memory leak
- Ułóż w kolejnościWarstwy cache'owania