Mari bercakap tentang mekanisme GC (pengumpulan sampah) dalam Node.js

Bagaimanakah

Nod melakukan GC (pengumpulan sampah)? Artikel berikut akan membawa anda melaluinya.

GC, Kutipan Sampah, kutipan sampah. Dalam pengaturcaraan, ia biasanya merujuk kepada mekanisme kitar semula memori automatik, yang kerap mengosongkan data yang tidak diperlukan.

Node.js menggunakan enjin V8 di bawahnya. V8 ialah enjin JavaScript berprestasi tinggi sumber terbuka oleh Google, ditulis dalam C. [Cadangan tutorial berkaitan: tutorial video nodejs]

Memori Node.js terbahagi terutamanya kepada tiga bahagian:

• Ruang kod: di mana segmen kod disimpan Tempat;

• Tindanan: Pembolehubah sementara yang dijana oleh timbunan panggilan fungsi, yang merupakan beberapa jenis asas, seperti nombor, rentetan, nilai Boolean dan rujukan objek (alamat disimpan, objek tidak disimpan sendiri).

• Heap: menyimpan data seperti objek;

Heap memory

Node.js underlying penggunaan Yang satu ialah V8 Mari kita terangkan mekanisme kitar semula memori V8.

Pertama sekali, semua objek dalam JS akan disimpan dalam ingatan timbunan. Apabila proses dibuat, saiz awal memori timbunan akan diperuntukkan, dan kemudian objek kami akan diletakkan di dalamnya.

Apabila semakin banyak objek, ingatan timbunan tidak akan mencukupi, dan ingatan timbunan akan berkembang secara dinamik. Jika had maksimum dicapai (biasanya 4GB pada masa kini), ralat limpahan timbunan berlaku dan proses Node.js ditamatkan.

Generasi Baharu dan Generasi Lama

V8 mula-mula membahagikan memori kepada dua bahagian, atau dua generasi:

• Generasi muda : menyelamatkan beberapa objek dengan masa kelangsungan hidup yang singkat;

• Generasi baharu adalah sangat kecil, dan beberapa objek dengan masa kelangsungan hidup yang singkat disimpan di sini Biasanya ia dikitar semula dengan kerap (seperti beberapa objek sementara dalam timbunan panggilan fungsi).

Saiz generasi baharu boleh diubah suai melalui

, dalam MB.

Selain itu, generasi lama menggunakan

untuk menetapkan algoritma Scavenge generasi baharu node --max-semi-space-size=SIZE index.js

--max-old-space-size=SIZEGenerasi baharu menggunakan algoritma Scavenge. Ia adalah berasaskan algoritma atas salinan.

Generasi baharu akan dibahagikan kepada dua ruang ini dipanggil semiruang iaitu:

Dari ruang: objek yang baru diisytiharkan akan diletakkan di sini

.

Ke ruang: ruang yang digunakan untuk penempatan semula

• Objek yang baru diisytiharkan akan diletakkan dalam ruang Dari Objek dalam ruang Dari disusun rapat. Penunjuk, objek sebelumnya dekat dengan objek seterusnya, dan ingatan berterusan, jadi tidak perlu risau tentang pemecahan memori.

• Apa yang dipanggil pemecahan memori merujuk kepada peruntukan ruang yang tidak sekata, mengakibatkan sejumlah besar ruang berterusan kecil yang tidak boleh dimuatkan ke dalam objek besar.

Apabila ruang Dari hampir penuh, kami akan melintasi untuk mencari objek aktif dan menyalinnya ke ruang Kepada. Pada ketika ini, ruang Dari sebenarnya kosong, dan kemudian kami menukar identiti Dari dan Kepada.

Jika sesetengah objek disalin beberapa kali, ia akan dianggap mempunyai masa hidup yang lebih lama dan akan dipindahkan ke generasi lama.

Kelebihan algoritma berasaskan salinan ini ialah ia boleh menangani masalah pemecahan memori dengan sangat baik , ia tidak sesuai untuk peruntukan yang terlalu besar Ruang memori lebih kepada GC tambahan.

Mark-Sweep dan Mark-Compact

Ruang generasi lama jauh lebih besar daripada ruang generasi baharu Ia mengandungi beberapa objek yang bertahan lama masa. Penggunaan ialah algoritma Mark-Sweep (penyingkiran tanda).

Pertama ialah peringkat penandaan. Cari semua objek yang boleh diakses daripada Set Root (timbunan pelaksanaan dan objek global) dan tandakannya sebagai objek aktif.

Selepas menanda, ia adalah fasa mengosongkan objek yang tidak ditanda sebenarnya menandakan alamat memori sebagai percuma.

Pendekatan ini akan membawa kepada

pemecahan ruang memori percuma

Apabila kita mencipta objek berterusan yang besar, kita tidak akan dapat mencari tempat untuk meletakkannya. Pada masa ini, Mark-Compact (pemadatan tanda) mesti digunakan untuk menyepadukan objek aktif yang berpecah-belah.

Mark-Compact akan mengalihkan semua salinan objek aktif ke satu hujung, dan kemudian sebelah lagi sempadan akan menjadi satu blok keseluruhan memori yang tersedia bersebelahan.

Memandangkan Mark-Sweep dan Mark-Compact mengambil masa yang lama dan menyekat urutan JavaScript, kami biasanya tidak melakukannya sekaligus, tetapi menggunakan penandaan tambahan (Pemarkahan Bertambah) . Ini bermakna menandakan secara berselang-seli, mengambil langkah kecil dan berselang-seli pengumpulan sampah dan logik aplikasi.

Selain itu, V8 juga melakukan penandaan selari dan pembersihan selari untuk meningkatkan kecekapan pelaksanaan.

Lihat maklumat berkaitan memori

Kita boleh mendapatkan beberapa maklumat berkaitan memori melalui kaedah proses.memoryUsage.

process.memoryUsage();

Kandungan output ialah:

{
  rss: 35454976,
  heapTotal: 7127040,
  heapUsed: 5287088,
  external: 958852,
  arrayBuffers: 11314
}

Penjelasan

• rss: saiz set pemastautin (saiz set pemastautin), termasuk coretan kod , ingatan timbunan, tindanan dan bahagian lain.

• Jumlah timbunan: jumlah saiz memori timbunan V8; >luaran: Saiz memori selain daripada V8 merujuk kepada memori yang diduduki oleh objek C, seperti data Penampan.

• arrayBuffers:

  dan
saiz memori yang berkaitan, sebahagian daripada luaran.
Unit nombor di atas ialah bait.

• ArrayBufferUji had memori maksimumSharedArrayBuffer

Tulis skrip yang menggunakan pemasa untuk menjadikan tatasusunan membesar secara berterusan dan cetak penggunaan memori timbunan sehingga memori melimpah.

Perhatian khusus harus diberikan kepada tidak menggunakan Penampan untuk ujian. Oleh kerana Buffer ialah objek pemprosesan binari yang unik untuk Node.js Ia tidak dilaksanakan secara berasingan oleh Node.js dalam C. Ia tidak memperuntukkan memori melalui V8 dan tergolong dalam timbunan luar. ingatan.

Komputer yang saya gunakan ialah macbook pro M1 Pro, versi Node.js ialah

const format = function (bytes) {
  return (bytes / 1024 / 1024).toFixed(2) + " MB";
};

const printMemoryUsage = function () {
  const memoryUsage = process.memoryUsage();
  console.log(
    `heapTotal: ${format(memoryUsage.heapTotal)}, heapUsed: ${format(
      memoryUsage.heapUsed
    )}`
  );
};

const bigArray = [];
setInterval(function () {
  bigArray.push(new Array(20 * 1024 * 1024));
  printMemoryUsage();
}, 500);

dan versi V8 yang digunakan ialah 9.4.146.26-node.22 (diperolehi melalui process.versions.v8 ).

Hasil keluaran ialah (beberapa maklumat berlebihan ditinggalkan):

Seperti yang anda lihat, had memori melebihi selepas 4000 MB, limpahan timbunan berlaku dan kemudian proses keluar. Ambil perhatian bahawa pada mesin saya, memori maksimum lalai ialah 4G.

Memori maksimum sebenar adalah berkaitan dengan mesin yang sedang dijalankan. Jika saiz memori mesin anda ialah 2G, memori maksimum akan ditetapkan kepada 1.5G. v16.17.0

Untuk lebih banyak pengetahuan berkaitan nod, sila lawati:

tutorial nodejs

!

heapTotal: 164.81 MB, heapUsed: 163.93 MB
heapTotal: 325.83 MB, heapUsed: 323.79 MB
heapTotal: 488.59 MB, heapUsed: 483.84 MB
...
heapTotal: 4036.44 MB, heapUsed: 4003.37 MB
heapTotal: 4196.45 MB, heapUsed: 4163.29 MB

<--- Last few GCs --->

[28033:0x140008000]    17968 ms: Mark-sweep 4003.2 (4036.4) -> 4003.1 (4036.4) MB, 2233.8 / 0.0 ms  (average mu = 0.565, current mu = 0.310) allocation failure scavenge might not succeed
[28033:0x140008000]    19815 ms: Mark-sweep 4163.3 (4196.5) -> 4163.1 (4196.5) MB, 1780.3 / 0.0 ms  (average mu = 0.413, current mu = 0.036) allocation failure scavenge might not succeed


<--- JS stacktrace --->

FATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory
...

Atas ialah kandungan terperinci Mari bercakap tentang mekanisme GC (pengumpulan sampah) dalam Node.js. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!