Memahami Pengumpulan Sampah dalam JavaScript dan Selainnya

Baru-baru ini, saya ditanya dalam temu bual teknikal bagaimana bahasa pengaturcaraan berbeza mengendalikan kutipan sampah. Ini adalah soalan yang mengejutkan namun menyegarkan, dan ia benar-benar menarik minat saya - Saya tidak pernah menemui perbincangan yang begitu mendalam tentang pengurusan ingatan dalam temu bual sebelum ini. Saya suka soalan ini dan ingin meneroka topik ini dengan lebih lanjut dalam catatan blog.

---

Pengurusan memori yang cekap adalah penting untuk aplikasi berprestasi tinggi. Kutipan Sampah (GC) Memastikan kitar semula automatik memori yang tidak digunakan untuk mengelakkan kebocoran memori dan ranap. Dalam artikel ini, kami akan menumpukan pada cara pengumpulan sampah berfungsi dalam JavaScript, meneroka kaedah lain yang digunakan dalam bahasa pengaturcaraan dan memberikan contoh untuk menggambarkan konsep ini.

---

Apakah pengumpulan sampah?

Pengumpulan sampah ialah proses menuntut semula memori yang diduduki oleh objek yang tidak lagi digunakan. Bahasa dengan pengumpulan sampah automatik mengabstrak proses ini supaya pembangun tidak perlu mengurus memori secara manual. Contohnya, JavaScript menggunakan pengumpul sampah penjejakan, manakala bahasa lain menggunakan teknik yang berbeza.

---

Pengumpulan sampah dalam JavaScript

JavaScript bergantung pada kaedah menjejak kutipan sampah, khususnya algoritma tanda-sapu. Mari kita pecahkan:

1. Algoritma tanda-jelas

Algoritma ini menentukan objek dalam ingatan yang "boleh dicapai" dan membebaskan objek yang tidak boleh dicapai:

1. Peringkat tanda:
   • Mulakan daripada objek "root" (contohnya, window dalam penyemak imbas atau objek global dalam Node.js).
   • Lelaran melalui semua objek yang boleh dicapai daripada objek akar ini dan tandainya sebagai "hidup".
2. Fasa Kosong:
   • Imbas timbunan dan lepaskan objek yang tidak ditandakan sebagai boleh dicapai.

Contoh:

<code class="language-javascript">function example() {
  let obj = { key: "value" }; // obj 可达
  let anotherObj = obj; // anotherObj 引用 obj

  anotherObj = null; // 引用计数减少
  obj = null; // 引用计数减少到 0
  // obj 现在不可达，将被垃圾回收
}</code>

2. Pengumpulan sampah generasi

Enjin JavaScript moden (seperti V8 dalam Chrome/Node.js) menggunakan GC Generasi untuk mengoptimumkan kutipan sampah. Memori terbahagi kepada:

• Generasi Baharu: Objek jangka pendek (seperti pembolehubah skop fungsi) disimpan di sini dan dikumpulkan dengan kerap.
• Generasi lama: Objek tahan lama (seperti pembolehubah global) disimpan di sini dan kurang kerap dikumpulkan.

Mengapa GC generasi lebih cekap?

• Kebanyakan objek dalam JavaScript bersifat sementara dan boleh dikumpulkan dengan cepat.
• Objek tahan lama dipindahkan ke generasi lama, mengurangkan keperluan untuk imbasan yang kerap.

---

Strategi kutipan sampah lain

Mari kita terokai cara bahasa lain mengendalikan pengumpulan sampah:

<.> 1. Rujukan Rujukan

Berapa banyak rujukan kepada pengiraan rujukan diarahkan ke objek. Apabila kiraan rujukan dikurangkan kepada 0, objek akan dikeluarkan.

Kelebihan:

memori mudah dan segera dikitar semula.

• sebelum meramalkan.
Kekurangan:

Rujukan Pekeliling

: Jika kedua -dua objek dirujuk antara satu sama lain, kiraan mereka tidak akan mencapai 0.

• Contoh: (kiraan rujukan python)

<.> 2. Pengurusan memori manual

c

<code class="language-javascript">function example() {
  let obj = { key: "value" }; // obj 可达
  let anotherObj = obj; // anotherObj 引用 obj

  anotherObj = null; // 引用计数减少
  obj = null; // 引用计数减少到 0
  // obj 现在不可达，将被垃圾回收
}</code>

dan

c bahasa memerlukan pemaju untuk menyatakan dan melepaskan memori.

Contoh:

(c memori pengurusan) Kelebihan:

sepenuhnya mengawal penggunaan memori.

<code class="language-python">a = []
b = []
a.append(b)
b.append(a)
# 这些对象相互引用，但不可达；现代 Python 的循环收集器可以处理这种情况。</code>

Kekurangan:

kebocoran memori (terlupa untuk melepaskan memori) dan penunjuk yang digantung (memori pelepasan sebelum ini).

<.> 3. Mengesan kitar semula sampah dengan pengumpul bulat

Beberapa bahasa (seperti python) menggabungkan kiraan rujukan

dan

pengesanan kitaran
• untuk merawat rujukan kitaran.

Pemungut kitaran mengimbas objek secara berkala untuk mengesan kitaran (kumpulan objek rujukan bersama yang tidak dapat diakses dari objek akar). Sebaik sahaja kitaran dijumpai, pemungut akan memusnahkannya dan mengitar semula memori. Pemungut kitaran menyelesaikan kelemahan terbesar (rujukan kitaran) pengiraan rujukan tulen. Mereka meningkatkan perbelanjaan tambahan, tetapi pastikan mereka tidak menyebabkan kebocoran memori akibat kitaran.

<.> 4. Peranti pemeriksaan peminjam Rust (tidak ada gc) Rust menggunakan kaedah yang berbeza,

sepenuhnya mengelakkan kitar semula sampah

. Sebaliknya, Rust menggunakan meminjam peranti pemeriksaan
• untuk menguatkuasakan peraturan pemilikan yang ketat:
🎜

: Hanya ada satu pemilik pada satu masa pada satu masa.

meminjam : Anda boleh meminjam rujukan (tidak jelas atau berubah -ubah), tetapi hanya membenarkan hanya satu rujukan pembolehubah untuk mencegah

Persaingan data . Kitaran hidup

: apabila nilai kesimpulan pengkompil melebihi skop skop dan secara automatik melepaskan memori.

• Sistem ini memastikan memori selamat dan tidak memerlukan GC tradisional, supaya karat mempunyai kelebihan prestasi pengurusan memori manual, sambil membantu mengelakkan kesilapan biasa seperti penunjuk yang digantung.
• Penjelasan Tambahan. Persaingan #data berlaku dalam pengaturcaraan serentak atau selari. Kerana tidak ada mekanisme (seperti kunci atau operasi atom) untuk menyelaraskan akses keserasian ini, keadaan terakhir data yang dikongsi mungkin tidak dapat diramalkan dan tidak konsisten -kesilapan yang sukar dicari.

  ---

  Strategi kitar semula sampah membandingkan

  ---

  方法	语言	优点	缺点
  引用计数	早期的 Python，Objective-C	立即回收，易于实现	循环引用失效
  追踪式（标记-清除）	JavaScript，Java	处理循环引用，对于大型堆效率高	停止世界暂停
  分代式 GC	JavaScript，Java	针对短暂的对象进行了优化	实现更复杂
  手动管理	C，C	完全控制	容易出错，需要仔细处理
  混合式（引用计数 循环收集器）	现代 Python	两全其美	仍然需要定期的循环检测
  借用检查器	Rust	无需 GC，防止数据竞争	学习曲线较陡峭，所有权规则

  javascript bagaimana menangani adegan biasa

  rujukan bulat

  Pemulihan Sampah Penjejakan JavaScript dapat mengendalikan rujukan kitaran:

  Pemantauan dan Penutupan Acara

  <code class="language-javascript">function example() {
    let obj = { key: "value" }; // obj 可达
    let anotherObj = obj; // anotherObj 引用 obj
  
    anotherObj = null; // 引用计数减少
    obj = null; // 引用计数减少到 0
    // obj 现在不可达，将被垃圾回收
  }</code>

  Jika monitor kejadian tidak dibersihkan dengan betul, ia secara tidak sengaja boleh menyebabkan kebocoran memori:
  ringkasan

  <code class="language-python">a = []
  b = []
  a.append(b)
  b.append(a)
  # 这些对象相互引用，但不可达；现代 Python 的循环收集器可以处理这种情况。</code>

  ---

  menggunakan JavaScript

  pengacau sampah yang dikesan dari algoritma

  dari memori memori pengurusan.
  1. Dibahagikan GC mengoptimumkan prestasi dengan memberi perhatian kepada objek pendek. Strategi yang berbeza menggunakan bahasa lain:
  Pengiraan rujukan
  2. : Mudah tetapi mudah berlaku. Pengurusan Manual
  : dikawal sepenuhnya tetapi mudah membuat kesilapan.
  3. Kaedah campuran
     • : digabungkan dengan strategi untuk mendapatkan prestasi yang lebih baik. Peranti Pemeriksaan Pinjaman Rust
     : Tiada GC, tetapi terdapat peraturan pemilikan yang ketat.
     Perhatikan kebocoran memori yang berpotensi dalam JavaScript, terutamanya dalam penutupan dan pemantauan acara.
     • Ini adalah peluang terbaik untuk memahami bahasa untuk strategi kitar semula sampah. Pada pendapat saya, memahami prinsip kerja kitar semula sampah bukan sahaja dapat membantu anda menulis kod yang cekap, tetapi juga membolehkan anda untuk debug dengan berkesan kesilapan yang berkaitan dengan ingatan.
     • rujukan
  JavaScript dan Pengurusan Memori: Dokumen MDN
  V8 Kitar Semula Sampah: Blog V8 Mengenai Kitar Semula Sampah
  Pemilikan Rust: Buku Bahasa Pengaturcaraan Rust
  kitar semula sampah java: Dokumen Oracle

  ---

  Python's GC: Python GC Module

Atas ialah kandungan terperinci Memahami Pengumpulan Sampah dalam JavaScript dan Selainnya. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!