Apakah mekanisme kutipan sampah jvm?

Mekanisme kutipan sampah jvm ialah GC (Pengumpulan Sampah), juga dipanggil pemungut sampah. Prinsip asas GC: Kitar semula objek yang tidak lagi digunakan dalam ingatan; kaedah yang digunakan untuk kitar semula dalam GC dipanggil pengumpul Memandangkan GC perlu menggunakan beberapa sumber dan masa, Java menganalisis ciri kitaran hayat objek dan menggunakan Objects dikumpulkan dalam generasi baru dan generasi lama untuk memendekkan jeda yang disebabkan oleh GC kepada aplikasi sebanyak mungkin.

Persekitaran pengendalian tutorial ini: sistem Windows 7, versi Java 8, komputer DELL G3.

Apakah pengumpulan sampah?

Salah satu kelebihan Java berbanding bahasa c dan c++ ialah ia didatangkan dengan pengumpul sampah merujuk kepada mengalih keluar memori timbunan dari semasa ke semasa. Objek yang tidak boleh dicapai tidak akan dikitar semula dengan serta-merta Pelaksanaan pengumpul sampah dalam program Java adalah automatik dan tidak boleh dipaksa oleh pengaturcara ialah mencadangkan pelaksanaan pengumpul sampah dengan memanggil kaedah System.gc. tetapi sama ada ia boleh dilaksanakan dan bila ia akan dilaksanakan tidak diketahui. Ini juga merupakan kelemahan utama pemungut sampah. Sudah tentu, kekurangan ini ditimbang oleh kemudahan besar yang dibawanya kepada pengaturcara.

Mengapa kutipan sampah diperlukan

Jika kutipan sampah tidak dilakukan, ingatan akan habis lambat laun kerana kita sentiasa memperuntukkan ruang memori tanpa kitar semula ia. Melainkan jika ingatan itu tidak terhingga, kita boleh memperuntukkannya sewenang-wenangnya tanpa mengitar semulanya, tetapi ini tidak berlaku. Oleh itu, kutipan sampah adalah perlu.

Prinsip kutipan sampah JVM

Terdapat kawasan timbunan dalam kawasan data masa jalan JVM dan timbunan ialah kumpulan objek yang besar. Sebilangan besar tika objek diuruskan dalam kumpulan objek ini, dan beberapa tahap rujukan objek dalam kolam adalah sangat dalam. Antara muka yang sering dipanggil menjana objek pada kadar yang sangat tinggi sesaat Pada masa yang sama, hubungan antara objek membentuk rangkaian yang besar.

Java telah mencipta suasana ingatan yang tidak terhingga, tetapi objek tidak boleh hanya meningkat tanpa berkurangan, jadi pengumpulan sampah diperlukan, kemudian bagaimana JVM menentukan objek yang perlu dikitar semula? Mana satu yang patut disimpan? Ini memerlukan penggunaan mekanisme kutipan sampah JVM, yang sering kita panggil GC (Pengumpulan Sampah), juga dipanggil pemungut sampah.

Prinsip asas GC (Pengumpulan Sampah): kitar semula objek yang tidak lagi digunakan dalam ingatan Kaedah yang digunakan untuk kitar semula dalam GC dipanggil pengumpul Memandangkan GC perlu menggunakan beberapa sumber dan Masa, selepas menganalisis ciri kitaran hayat objek, Java mengumpul objek mengikut kaedah generasi baru dan generasi lama untuk memendekkan jeda yang disebabkan oleh GC kepada aplikasi sebanyak mungkin

● Kepada generasi baru Pengumpulan objek dipanggil minor GC
● Pengumpulan objek dalam generasi lama dipanggil GC Penuh
● GC yang dipaksa dengan memanggil System.gc() secara aktif dalam atur cara ialah GC Penuh

Jenis rujukan Objek yang berbeza, GC akan menggunakan kaedah yang berbeza untuk mengitar semula rujukan objek JVM dibahagikan kepada empat jenis:
● Rujukan kuat: Secara lalai, objek menggunakan rujukan kuat (contoh objek ini tidak mempunyai rujukan objek lain), akan dikitar semula hanya apabila GC)
● Rujukan lembut: Rujukan lembut ialah aplikasi yang disediakan dalam Java yang lebih sesuai untuk senario caching (ia hanya akan GCed apabila memori tidak mencukupi)
● Rujukan Lemah: Ia pasti akan dikitar semula oleh GC semasa GC
● Rujukan maya: Kerana rujukan maya hanya digunakan untuk mengetahui sama ada objek itu GC

Objek ditandakan sebagai kaedah sampah

Struktur memori JVM merangkumi lima bidang utama: 程序计数器, 虚拟机栈, 本地方法栈, 堆区, 方法区. Antaranya, pembilang program, timbunan mesin maya, dan timbunan kaedah tempatan adalah tiga kawasan yang dilahirkan dan dimusnahkan dengan benang Oleh itu, peruntukan memori dan kitar semula kawasan ini adalah deterministik, dan tidak perlu mempertimbangkan isu kitar semula. terlalu banyak, kerana Apabila kaedah tamat atau benang tamat, memori secara semula jadi akan dikitar semula. Kawasan timbunan Java dan kawasan kaedah adalah berbeza Peruntukan dan kitar semula bahagian memori ini adalah dinamik, yang mana pengumpul sampah perlu memberi tumpuan.

1. Kaunter Rujukan

Pengiraan rujukan adalah strategi awal dalam pemungut sampah. Dalam pendekatan ini, setiap contoh objek dalam timbunan mempunyai kiraan rujukan. Apabila objek dicipta, contoh objek ditetapkan kepada pembolehubah dan kiraan pembolehubah ditetapkan kepada 1. Apabila mana-mana pembolehubah lain diberikan rujukan kepada objek ini, kiraan akan meningkat sebanyak 1 (a = b, kemudian pembilang bagi contoh objek yang dirujuk oleh b + 1), tetapi apabila rujukan contoh objek melebihi kitaran hayat atau ditetapkan kepada Apabila nilai baharu dicapai, kaunter rujukan contoh objek dikurangkan sebanyak 1. Mana-mana contoh objek dengan kaunter rujukan 0 boleh dikumpul sampah. Apabila contoh objek dikumpul sampah, kaunter rujukan mana-mana contoh objek yang dirujuknya dikurangkan dengan satu.

Kelebihan: Pengumpul pengiraan rujukan boleh dilaksanakan dengan cepat dan saling berkaitan dengan perjalanan program. Ia lebih bermanfaat untuk persekitaran masa nyata di mana program tidak perlu diganggu untuk masa yang lama.
Kelemahan: Tidak dapat mengesan rujukan pekeliling. Jika objek induk mempunyai rujukan kepada objek anak, objek anak pula merujuk kepada objek induk. Dengan cara ini, kiraan rujukan mereka tidak boleh menjadi 0.

Analisis kod di atas dengan kaedah pengiraan rujukan:

2. Analisis kebolehcapaian

Algoritma kebolehcapaian ialah algoritma dan program yang digunakan oleh mesin maya arus perdana hubungan sebagai graf Bermula dari nod GC Roots, cari nod rujukan yang sepadan Selepas mencari nod ini, teruskan mencari nod rujukan nod ini apabila semua nod rujukan dicari, nod yang selebihnya akan dipertimbangkan menjadi nod yang tidak dirujuk, iaitu, nod yang tidak berguna akan dinilai sebagai objek kitar semula.

Dalam bahasa Java, objek yang boleh digunakan sebagai GC Roots termasuk jenis berikut:
● Objek yang dirujuk dalam tindanan mesin maya (jadual pembolehubah setempat dalam bingkai tindanan); kawasan kaedah Objek yang dirujuk oleh atribut statik kelas;
● Objek yang dirujuk oleh pemalar dalam kawasan kaedah;



Boleh disimpulkan bahawa contoh objek 1, 2, 4, dan 6 semuanya mempunyai kebolehcapaian objek, iaitu objek yang masih hidup dan objek yang tidak boleh dikitar semula oleh GC. Walaupun kejadian Caprice 3 dan 5 disambungkan secara langsung, tiada GC Roots disambungkan kepada mereka, iaitu objek yang tidak boleh dicapai oleh GC Roots akan dikitar semula oleh GC.

3. Algoritma pengumpulan sampah

1 algoritma adalah seperti berikut Ia mempunyai nama yang sama dan dibahagikan kepada dua peringkat: "menanda" dan "membersihkan": pertama, tandakan semua objek yang perlu dikitar semula, dan selepas penandaan selesai, semua objek yang ditanda akan dikitar semula secara seragam.

Fasa penandaan:

Proses penandaan sebenarnya ialah proses algoritma analisis kebolehcapaian yang diperkenalkan sebelum ini Ia merentasi semua objek GC Roots dan menjadikan objek boleh dicapai daripada GCRoots Each objek ditandakan dengan pengecam, biasanya dalam pengepala objek, dan direkodkan sebagai objek yang boleh dicapai. Fasa pembersihan:

Proses pembersihan adalah untuk melintasi ingatan timbunan Jika didapati objek tidak ditandakan sebagai objek yang boleh dicapai (dengan membaca objek maklumat pengepala ), ia akan dikitar semula.

Gambar di atas ialah gambarajah skematik algoritma penandaan/pembersihan Dalam fasa penandaan, objek B boleh diakses dari objek GC Root 1, dan objek E boleh diakses dari objek B. Oleh itu, GC Root 1 hingga B dan E semuanya boleh dicapai Begitu juga, objek F, G, J dan K adalah semua objek yang boleh dicapai dalam fasa pembersihan, semua objek yang tidak boleh dicapai akan dikitar semula.

Apabila pemungut sampah melakukan GC, semua urutan pelaksanaan Java mesti dihentikan (juga dikenali sebagai "Stop The World" Sebabnya ialah apabila analisis kebolehcapaian dilakukan semasa fasa penandaan, hubungan rujukan objek tidak boleh kekal semasa proses analisis. Perubahan keadaan, jika tidak, ketepatan keputusan analisis kebolehcapaian tidak dapat dijamin. Benang aplikasi tidak akan disambung semula sehingga tanda dikosongkan.

Kelemahan algoritma penandaan/kosongkan:

● Isu kecekapan Kecekapan kedua-dua peringkat penandaan dan pembersihan tidak tinggi , kerana kedua-dua peringkat perlu melintasi objek dalam ingatan, dan banyak kali bilangan contoh objek dalam ingatan adalah sangat besar, yang pastinya sangat memakan masa, dan aplikasi perlu dihentikan semasa GC, yang akan membawa kepada pengalaman pengguna yang sangat lemah.
● Masalah ruang
Selepas tanda dikosongkan, sejumlah besar serpihan memori terputus akan dihasilkan (seperti yang boleh dilihat daripada gambar di atas terlalu banyak serpihan ruang memori boleh menyebabkan perlu Apabila memperuntukkan objek yang lebih besar, ingatan bersebelahan yang tidak mencukupi tidak dapat ditemui dan satu lagi tindakan kutipan sampah perlu dicetuskan lebih awal.

2. Algoritma salin

Algoritma salin membahagikan memori yang tersedia kepada dua blok bersaiz sama mengikut kapasiti, dan menggunakan satu blok pada satu masa. Apabila blok memori ini kehabisan, salin objek yang masih hidup ke blok memori lain, dan kemudian bersihkan semua objek dalam blok memori ini sekaligus

Algoritma salin mengitar semula memori keseluruhan separuh kawasan setiap kali, yang mengurangkan masa melintasi objek yang ditandakan Apabila mengosongkan objek kawasan yang digunakan, tidak perlu melintasi, keseluruhan memori kawasan dikosongkan secara langsung, dan objek yang masih hidup disalin Kawasan yang dikhaskan juga disimpan dalam susunan alamat, yang menyelesaikan masalah pemecahan memori Apabila memperuntukkan memori objek, tidak perlu mempertimbangkan isu yang rumit seperti pemecahan memori Anda hanya perlu memperuntukkan memori dalam susunan.

Kelemahan algoritma salin:
Algoritma salin adalah mudah dan cekap, mengoptimumkan kecekapan rendah tanda dan algoritma jelas serta masalah memori pemecahan. Terdapat kelemahan:
● Kurangkan memori kepada separuh daripada saiz asal, yang membazirkan separuh daripada ruang memori Kosnya terlalu tinggi
● Jika kadar kemandirian objek sangat tinggi, dalam kes yang melampau, dengan mengandaikan kadar survival objek adalah 100%, maka kita perlu Kos masa menyalin objek tidak boleh diabaikan.

3. Algoritma Mark-Collate

Algoritma Mark-Collate Algoritma ini hampir sama dengan algoritma Mark/Sweep. Algoritma kumpulkan masih sama seperti Algoritma tanda/jelas adalah sama, tetapi langkah seterusnya bukan untuk mengitar semula objek kitar semula secara langsung, tetapi untuk mengalihkan semua objek yang masih hidup ke satu hujung, dan kemudian membersihkan memori secara langsung di luar tepi hujung.

Seperti yang anda lihat, objek kitar semula dibersihkan selepas dikitar semula, dan objek yang masih hidup disusun dalam ingatan mengikut peraturan. Dengan cara ini, apabila kita memperuntukkan memori kepada objek baru, jvm hanya perlu memegang alamat permulaan memori. Algoritma mark/organize mengimbangi masalah pemecahan memori bagi algoritma mark/clear dan menghapuskan kos tinggi untuk mengurangkan separuh memori algoritma salinan Ia boleh dikatakan membunuh dua burung dengan satu batu.

Kelemahan Penandaan/Organisasi:
● Ketidakcekapan: Bukan sahaja objek yang masih hidup mesti ditanda, tetapi juga alamat rujukan semua objek yang masih hidup mesti diatur. Dari segi kecekapan Daripada menyalin algoritma.

4. Algoritma pengumpulan generasi

Idea algoritma pengumpulan generasi adalah untuk membahagikan memori kepada beberapa blok mengikut kitaran hayat objek yang berbeza. timbunan Java dibahagikan kepada Generasi baru dan generasi lama (terdapat juga generasi kekal, yang merupakan pelaksanaan unik HotSpot. Pelaksanaan mesin maya lain tidak mempunyai konsep ini. Kesan pengumpulan generasi kekal adalah sangat buruk, dan generasi kekal secara amnya jarang sampah dikumpul), supaya anda boleh Algoritma pengumpulan yang paling sesuai diguna pakai mengikut ciri-ciri setiap era.

Ciri:
Generasi baharu: ia dilahirkan dan hilang dengan cepat, dan masa kelangsungan hidupnya sangat singkat. Gunakan algoritma replikasi untuk mengumpul
Generasi lama: Bertahan selepas berbilang GC Minor dan mempunyai tempoh kelangsungan hidup yang panjang. Gunakan algoritma mark/clear atau mark/organize algorithm untuk mengumpul generasi lama

Setiap kali kutipan sampah dilakukan pada generasi baru, didapati sebilangan besar objek mati dan hanya sedikit yang bertahan. algoritma penyalinan digunakan untuk mengitar semula generasi baharu, yang hanya memerlukan sedikit usaha Pengumpulan boleh diselesaikan dengan kos menyalin objek
Kadar kemandirian objek dalam generasi lama adalah tinggi dan tidak sesuai untuk menggunakan algoritma penyalinan Selain itu, jika generasi lama menggunakan algoritma penyalinan, ia tidak akan mempunyai ruang tambahan untuk jaminan peruntukan, jadi teg mesti digunakan atau algoritma mark/collate untuk kitar semula.

Objek dalam generasi baharu "hidup dan mati". Setiap kali GC berlaku, sejumlah besar objek akan mati dan sebilangan kecil akan bertahan Algoritma replikasi digunakan. Generasi baharu dibahagikan kepada kawasan Eden dan kawasan Survivor (Survivor from, Survivor to), dan nisbah saiz lalai kepada 8:1:1.
Oleh kerana kadar kemandirian objek adalah tinggi dan tiada ruang tambahan untuk jaminan peruntukan, algoritma tanda-jelas atau pelengkap tanda digunakan untuk objek dalam generasi lama.
Objek yang baru dijana memasuki kawasan Eden terlebih dahulu Apabila kawasan Eden penuh, Survivor dari digunakan Apabila Survivor dari juga penuh, Minor GC (GC generasi baharu) dilakukan untuk menyalin objek yang masih hidup di Eden dan Survivor dari. . Masukkan Survivor ke, kemudian kosongkan Eden dan Survivor daripada Pada masa ini, Survivor asal menjadi Survivor baharu kepada, dan Survivor asal menjadi Survivor baharu. Semasa menyalin, jika Survivor to tidak dapat menampung semua objek yang masih hidup, objek tersebut akan disalin ke generasi lama berdasarkan jaminan peruntukan generasi lama (serupa dengan jaminan pinjaman bank Jika generasi lama tidak dapat menampungnya, GC Penuh). (generasi lama) akan dilakukan.
Objek besar terus memasuki generasi lama: Terdapat konfigurasi parameter dalam JVM
-XX:PretenureSizeThreshold, yang menyebabkan objek yang lebih besar daripada nilai tetapan ini untuk terus memasuki generasi lama kejadian antara kawasan Eden dan Survivor salinan Memori.
Objek yang masih hidup jangka panjang memasuki generasi lama: JVM mentakrifkan pembilang umur objek untuk setiap objek Jika objek itu masih bertahan selepas Eden dilahirkan dan melepasi GC Minor pertama, dan boleh ditampung oleh Survivor, ia akan menjadi. berpindah ke Survivor dan umur Tetapkan kepada 1. Jika ia tidak bertahan dalam GC Kecil, umurnya akan dinaikkan sebanyak 1. Apabila umurnya mencapai tahap tertentu (lalai ialah 15 tahun, yang boleh ditetapkan melalui XX:MaxTenuringThreshold), ia akan dipindahkan ke generasi lama . Walau bagaimanapun, JVM tidak selalu memerlukan umur mesti mencapai umur maksimum sebelum dinaikkan pangkat kepada generasi lama Jika jumlah saiz semua objek pada umur yang sama (contohnya, umur ialah x) dalam ruang Survivor ialah. lebih daripada separuh daripada Survivor, semua objek dengan umur lebih besar daripada atau sama dengan x akan terus memasuki generasi lama , tidak perlu menunggu sehingga keperluan umur maksimum.

Kitar semula generasi:

Kami menggunakan objek1 untuk menggambarkan trajektori kitar semulanya dalam algoritma pengumpulan sampah generasi.

1. Objek1 baru dicipta dan dilahirkan di kawasan Eden generasi baru.

2. GC Minor, objek1 masih hidup dan dipindahkan ke ruang Daripada yang masih hidup, yang masih dalam generasi baharu.

3. GC Minor, objek1 masih hidup pada masa ini, objek1 akan dialihkan ke kawasan ToSuv masa, umur objek1 ialah umur +1.

4 GC Minor, objek1 masih hidup Pada masa ini, objek yang sama umurnya dengan objek1 yang terselamat belum mencapai separuh daripada yang terselamat. kali ini, melalui algoritma salin, fromSuv dan kawasan Tosuv ditukar, dan objek yang masih hidup dialihkan ke Tosuv.

5 GC Minor, objek1 masih hidup Pada masa ini, objek yang sama umurnya dengan objek1 yang terselamat telah mencapai lebih separuh daripada yang terselamat. kawasan toSuv penuh), dan object1 dialihkan ke kawasan generasi lama.

6 Selepas objek1 bertahan untuk satu tempoh masa, didapati objek1 tidak dapat dicapai oleh GcRoots pada masa ini, dan nisbah ruang generasi lama telah melebihi ambang, mencetuskan majorGC (ia juga boleh dianggap Ia adalah fullGC, tetapi ia perlu dihubungi oleh pemungut sampah Pada masa ini, objek1 dikitar semula). fullGC akan mencetuskan hentikan dunia.

Dalam generasi baharu di atas, kami telah menyebut umur objek tersebut bertahan dalam keadaan terselamat dan tidak akan serta-merta dinaikkan ke objek generasi lama untuk mengelakkan kerosakan yang berlebihan. kepada generasi lama. Impak besar, mereka mesti memenuhi syarat berikut sebelum mereka boleh dinaikkan pangkat:
1. Selepas gc kecil, umur objek yang masih hidup di kawasan yang terselamat akan menjadi +1 apabila melebihi (lalai) 15 , ia akan dipindahkan ke hari tua.
2. Objek dinamik Jika gabungan saiz semua objek yang sama umur dalam ruang yang terselamat adalah lebih besar daripada separuh ruang yang terselamat, objek yang umurnya lebih besar daripada atau sama dengan umur tersebut boleh terus memasuki generasi lama.

Atas ialah kandungan terperinci Apakah mekanisme kutipan sampah jvm?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!