Bagaimana cara kerja Java Garbage Collection dengan Referensi Lingkaran?

Dari pemahaman saya, pengumpulan sampah di Jawa membersihkan beberapa objek jika tidak ada yang 'menunjuk' ke objek itu.

Pertanyaan saya adalah, apa yang terjadi jika kita memiliki sesuatu seperti ini:

class Node {
    public object value;
    public Node next;
    public Node(object o, Node n) { value = 0; next = n;}
}

//...some code
{
    Node a = new Node("a", null), 
         b = new Node("b", a), 
         c = new Node("c", b);
    a.next = c;
} //end of scope
//...other code

a,, bdan charus dikumpulkan, tetapi semuanya dirujuk oleh objek lain.

Bagaimana cara pengumpulan sampah Jawa menangani ini? (Atau itu hanya menguras memori?)

GC Jawa menganggap objek "sampah" jika tidak dapat dijangkau melalui rantai mulai dari akar pengumpulan sampah, sehingga objek ini akan dikumpulkan. Meskipun objek dapat menunjuk satu sama lain untuk membentuk siklus, mereka tetap sampah jika terpotong dari akar.

Lihat bagian tentang benda-benda yang tidak dapat dijangkau di Lampiran A: Kebenaran Tentang Pengumpulan Sampah di Java Platform Performance: Strategi dan Taktik untuk detail berdarah.

ya pengumpul Sampah Jawa menangani referensi melingkar!

How?

Ada benda-benda khusus yang disebut akar pengumpulan sampah (GC root). Ini selalu dapat dijangkau dan begitu pula objek apa pun yang memiliki mereka pada akarnya sendiri.

Aplikasi Java sederhana memiliki akar GC berikut:

1. Variabel lokal dalam metode utama
2. Utas utama
3. Variabel statis dari kelas utama

Untuk menentukan objek mana yang tidak lagi digunakan, JVM sebentar-sebentar menjalankan apa yang sangat tepat disebut algoritma mark-and-sweep . Ini berfungsi sebagai berikut

1. Algoritme melintasi semua referensi objek, dimulai dengan akar GC, dan menandai setiap objek yang ditemukan hidup.
2. Semua memori tumpukan yang tidak ditempati oleh objek yang ditandai direklamasi. Itu hanya ditandai sebagai bebas, pada dasarnya disapu bebas dari benda yang tidak digunakan.

Jadi, jika ada objek yang tidak dapat dijangkau dari akar GC (bahkan jika itu direferensikan sendiri atau dirujuk siklik) itu akan dikenakan pengumpulan sampah.

Ofcourse kadang-kadang hal ini dapat menyebabkan kebocoran memori jika programmer lupa untuk merujuk objek.

Sumber: Manajemen Memori Java

Seorang pengumpul sampah dimulai dari beberapa tempat "root" yang selalu dianggap "dapat dijangkau", seperti register CPU, stack, dan variabel global. Ini bekerja dengan menemukan petunjuk di area tersebut, dan secara rekursif menemukan semua yang mereka tuju. Setelah itu ditemukan semua itu, segala sesuatu yang lain adalah sampah.

Tentu saja ada beberapa variasi, kebanyakan demi kecepatan. Sebagai contoh, sebagian besar pengumpul sampah modern adalah "generasi", yang berarti bahwa mereka membagi benda menjadi beberapa generasi, dan seiring bertambahnya usia, pengumpul sampah berjalan lebih lama dan lebih lama antara waktu yang mencoba untuk mencari tahu apakah benda itu masih valid atau tidak - itu hanya mulai berasumsi bahwa jika ia telah hidup lama, kemungkinannya cukup bagus bahwa ia akan terus hidup lebih lama lagi.

Meskipun demikian, ide dasarnya tetap sama: semuanya didasarkan pada mulai dari beberapa set root hal-hal yang diperlukan begitu saja masih dapat digunakan, dan kemudian mengejar semua petunjuk untuk menemukan apa lagi yang bisa digunakan.

Di samping menarik: semoga orang sering terkejut dengan tingkat kesamaan antara bagian pengumpul sampah dan kode untuk mengatur objek untuk hal-hal seperti panggilan prosedur jarak jauh. Dalam setiap kasus, Anda mulai dari beberapa root set objek, dan mengejar pointer untuk menemukan semua objek lain yang merujuk ...

Anda benar. Bentuk spesifik pengumpulan sampah yang Anda gambarkan disebut " penghitungan referensi ". Cara kerjanya (secara konseptual, setidaknya, sebagian besar implementasi modern penghitungan referensi sebenarnya diimplementasikan dengan sangat berbeda) dalam kasus yang paling sederhana, terlihat seperti ini:

• setiap kali referensi ke objek ditambahkan (misalnya ditugaskan ke variabel atau bidang, diteruskan ke metode, dan sebagainya), jumlah referensi meningkat sebesar 1
• setiap kali referensi ke suatu objek dihapus (metode kembali, variabel keluar dari lingkup, bidang ditugaskan kembali ke objek yang berbeda atau objek yang berisi bidang itu sendiri mengumpulkan sampah), jumlah referensi berkurang 1
• segera setelah jumlah referensi mencapai 0, tidak ada lagi referensi ke objek, yang berarti tidak ada yang dapat menggunakannya lagi, oleh karena itu adalah sampah dan dapat dikumpulkan

Dan strategi sederhana ini memiliki masalah yang Anda jelaskan: jika A referensi B dan B referensi A, maka kedua jumlah referensi mereka tidak akan pernah kurang dari 1, yang berarti mereka tidak akan pernah dikumpulkan.

Ada empat cara untuk mengatasi masalah ini:

1. Abaikan itu. Jika Anda memiliki cukup memori, siklus Anda kecil dan jarang dan runtime Anda pendek, mungkin Anda bisa lolos dengan tidak mengumpulkan siklus. Pikirkan juru bahasa skrip shell: skrip shell biasanya hanya berjalan selama beberapa detik dan tidak mengalokasikan banyak memori.
2. Gabungkan referensi Anda menghitung pengumpul sampah dengan pengumpul sampah lain yang tidak memiliki masalah dengan siklus. CPython melakukan ini, misalnya: pengumpul sampah utama di CPython adalah pengumpul penghitungan referensi, tetapi dari waktu ke waktu pengumpul sampah penelusuran dijalankan untuk mengumpulkan siklus.
3. Deteksi siklusnya. Sayangnya, mendeteksi siklus dalam grafik adalah operasi yang agak mahal. Secara khusus, ini membutuhkan biaya overhead yang hampir sama dengan kolektor pelacak, jadi Anda bisa menggunakan salah satunya.
4. Jangan menerapkan algoritme dengan cara naif seperti Anda dan saya: sejak tahun 1970-an, ada beberapa algoritma yang cukup menarik yang dikembangkan yang menggabungkan deteksi siklus dan penghitungan referensi dalam satu operasi dengan cara yang pintar yang secara signifikan lebih murah daripada melakukannya baik secara terpisah atau melakukan tracing collector.

Ngomong-ngomong, cara utama lainnya untuk mengimplementasikan pengumpul sampah (dan saya sudah mengisyaratkan bahwa beberapa kali di atas), sedang melacak . Seorang kolektor tracing didasarkan pada konsep reachability . Anda mulai dengan beberapa set root yang Anda tahu selalu dapat dijangkau (konstanta global, misalnya, atau Objectkelas, ruang lingkup leksikal saat ini, bingkai stack saat ini) dan dari sana Anda melacak semua objek yang dapat dijangkau dari set root, kemudian semua objek yang dapat dijangkau dari objek yang dapat dijangkau dari root set dan seterusnya, sampai Anda memiliki penutupan transitif. Segala sesuatu yang tidak ada dalam penutupan itu adalah sampah.

Karena sebuah siklus hanya dapat dicapai dalam dirinya sendiri, tetapi tidak dapat dicapai dari set root, itu akan dikumpulkan.

Java GCs sebenarnya tidak berperilaku seperti yang Anda gambarkan. Lebih akurat untuk mengatakan bahwa mereka mulai dari satu set objek dasar, sering disebut "akar GC", dan akan mengumpulkan objek apa pun yang tidak dapat dijangkau dari root.
Akar GC mencakup hal-hal seperti:

• variabel statis
• variabel lokal (termasuk semua referensi 'ini' yang berlaku) saat ini di tumpukan thread yang sedang berjalan

Jadi, dalam kasus Anda, setelah variabel lokal a, b, dan c keluar dari ruang lingkup di akhir metode Anda, tidak ada lagi akar GC yang berisi, secara langsung atau tidak langsung, referensi ke salah satu dari tiga node Anda, dan mereka akan memenuhi syarat untuk pengumpulan sampah.

Tautan TofuBeer memiliki detail lebih banyak jika Anda menginginkannya.

Artikel ini (tidak lagi tersedia) membahas tentang pengumpul sampah (secara konseptual ... ada beberapa implementasi). Bagian yang relevan dengan posting Anda adalah "A.3.4 Tidak Dapat Dicapai":

A.3.4 Tidak Terjangkau Suatu objek memasuki kondisi tidak dapat dijangkau ketika tidak ada referensi yang lebih kuat untuk itu ada. Ketika sebuah objek tidak dapat dijangkau, itu adalah kandidat untuk koleksi. Perhatikan kata-katanya: Hanya karena suatu objek adalah kandidat untuk koleksi tidak berarti itu akan segera dikumpulkan. JVM bebas untuk menunda pengumpulan sampai ada kebutuhan mendesak untuk memori yang dikonsumsi oleh objek.

Pengumpulan sampah biasanya tidak berarti "membersihkan beberapa objek jika tidak ada yang lain 'menunjuk' ke objek itu" (itu penghitungan referensi). Pengumpulan sampah secara kasar berarti menemukan benda yang tidak dapat dijangkau dari program.

Jadi, dalam contoh Anda, setelah a, b, dan c keluar dari ruang lingkup, mereka dapat dikumpulkan oleh GC, karena Anda tidak dapat mengakses objek ini lagi.

Bill menjawab pertanyaan Anda secara langsung. Seperti yang dikatakan Amnon, definisi Anda tentang pengumpulan sampah hanyalah penghitungan referensi. Saya hanya ingin menambahkan bahwa bahkan algoritma yang sangat sederhana seperti mark dan sweep serta koleksi salin dengan mudah menangani referensi melingkar. Jadi, tidak ada yang ajaib tentang itu!