Mekanisme pengumpulan sampah PHP didasarkan pada penghitungan rujukan, tetapi rujukan bulat perlu diproses oleh pemungut sampah pekeliling berkala; 1. Rujukan kiraan rujukan segera memori apabila tidak ada rujukan kepada pembolehubah; 2. Rujukan rujukan menyebabkan memori tidak dapat dikeluarkan secara automatik, dan ia bergantung kepada GC untuk mengesan dan membersihkan; 3. GC dicetuskan apabila zval "akar yang mungkin" mencapai ambang atau panggilan secara manual gc_collect_cycles (); 4. Aplikasi PHP jangka panjang harus memantau gc_status () dan hubungi gc_collect_cycles () dalam masa untuk mengelakkan kebocoran ingatan; 5. Amalan terbaik termasuk mengelakkan rujukan bulat, menggunakan gc_disable () untuk mengoptimumkan bidang utama prestasi, dan objek dereference melalui kaedah ORM yang jelas (), dan akhirnya memastikan pengurusan ingatan yang cekap untuk mengatasi senario yang kompleks.

Mekanisme Koleksi Sampah PHP (GC) sering diabaikan oleh pemaju yang menganggap bahawa, sebagai bahasa skrip peringkat tinggi, pengurusan memori sepenuhnya ditarik balik. Walaupun PHP mengendalikan kebanyakan pembersihan memori secara automatik melalui pengiraan rujukan, memahami proses pengumpulan sampah dalamannya-terutamanya bagaimana ia berkaitan dengan rujukan bulat dan pembersihan sumber-boleh membantu mengoptimumkan prestasi dan mengelakkan kebocoran memori dalam skrip jangka panjang atau aplikasi yang kompleks.

Mari kita menyelam dalam bagaimana PHP menguruskan ingatan dan koleksi sampah di bawah tudung.

Bagaimana Memori Pengurusan PHP: Pengiraan Rujukan

Pada terasnya, PHP menggunakan pengiraan rujukan sebagai kaedah utama untuk menjejaki dan mengurus memori. Setiap pembolehubah dalam PHP diwakili secara dalaman sebagai zval (nilai zend), yang memegang nilai dan metadata seperti jenis dan kiraan rujukan.

Setiap kali pembolehubah diberikan atau diluluskan, kiraan rujukan zval meningkat. Apabila pemboleh ubah keluar dari skop atau tidak tersendiri, kiraan rujukan berkurangan. Setelah kiraan mencapai sifar, PHP segera membebaskan memori yang berkaitan.

Contohnya:

 $ a = "hello";
$ b = $ a; // refcount menjadi 2
unset ($ a); // refcount jatuh ke 1
unset ($ b); // refcount jatuh ke 0 → memori dibebaskan

Sistem ini adalah cekap dan menentukan -mory dibebaskan sebaik sahaja ia tidak lagi diperlukan, kecuali apabila rujukan bulat terlibat.

Masalahnya: Rujukan Pekeliling

Pengiraan rujukan gagal apabila rujukan pekeliling berlaku -apabila dua atau lebih objek merujuk satu sama lain, mewujudkan kitaran yang membuat kiraan rujukan mereka melebihi sifar, walaupun mereka tidak lagi dapat diakses dari akar permohonan.

Contoh:

 nod kelas {
    ibu bapa awam $;
}

$ a = nod baru ();
$ b = nod baru ();
$ a-> ibu bapa = $ b;
$ b-> ibu bapa = $ a;

unset ($ a, $ b); // refcount tidak mencapai sifar kerana kitaran

Walaupun $a dan $b tidak teratur, masing -masing masih memegang rujukan kepada yang lain, jadi zval mereka tidak pernah dibersihkan. Ini mewujudkan kebocoran memori .

Di sinilah pemungut sampah kitaran PHP masuk.

Pemungut sampah kitaran PHP

Untuk menyelesaikannya, PHP melaksanakan pengumpul sampah kitaran yang berjalan secara berkala untuk mengesan dan membersihkan rujukan bulat. Ia diperkenalkan dalam Php 5.3 dan berfungsi bersama -sama dengan pengiraan rujukan.

Bagaimana ia berfungsi

GC tidak berjalan pada setiap unset() atau keluar dari ruang lingkup. Sebaliknya, ia mencetuskan dalam keadaan tertentu:

• Apabila bilangan zvals "akar yang mungkin" mencapai ambang (lalai: 10,000).
• Atau secara manual dicetuskan melalui gc_collect_cycles() .

"Akar yang mungkin" adalah zval dengan kiraan rujukan> 0 yang mungkin menjadi sebahagian daripada kitaran. Apabila objek tersebut dikesan, mereka ditambah kepada penampan akar .

Apabila penampan mengisi, GC PHP menjalankan algoritma pengesanan kitaran dua fasa:

1. Tanda fasa : melintasi semua objek akar yang mungkin dan tandakannya sebagai "kelabu".
2. Fasa imbasan : Bagi setiap objek, pengurangan kiraan rujukan anak -anaknya. Sekiranya reflount kanak -kanak tetap> 0 tetapi bukan akar, ia adalah sebahagian daripada kitaran.

Objek yang dikenal pasti sebagai sebahagian daripada kitaran kemudian dibersihkan, dan ingatan mereka dibebaskan.

Anda boleh mencetuskan ini secara manual:

 gc_collect_cycles (); // Force GC Run

Dan memantau:

 var_dump (gc_enabled ()); // bool (benar)
var_dump (gc_status ()); // menunjukkan berjalan, dikumpulkan, dll.

Pertimbangan Prestasi

Walaupun GC menghalang kebocoran memori, ia tidak percuma:

• Ia menambah overhead apabila menjejaki kitaran berpotensi.
• Menjalankan gc_collect_cycles() terlalu kerap dapat merendahkan prestasi.
• Dalam kebanyakan skrip web (permintaan jangka pendek), kesannya boleh diabaikan kerana memori dibebaskan apabila permintaan berakhir.

Walau bagaimanapun, dalam aplikasi PHP yang lama (contohnya, daemon, pekerja CLI, atau pelayan berasaskan swoole), kitaran yang tidak dapat dikumpulkan boleh mengumpul dan menyebabkan kembung memori.

Amalan terbaik

• Elakkan rujukan pekeliling apabila mungkin (misalnya, gunakan rujukan lemah atau memecahkan kitaran secara manual).
• Hubungi gc_disable() dalam bahagian prestasi kritikal jika anda pasti tidak ada kitaran.
• Gunakan gc_enable() dan memantau gc_status() dalam skrip jangka panjang untuk mengesan koleksi.
• Penggunaan memori profil dengan alat seperti memory_get_usage() dan xdebug.

Contoh dunia nyata: entiti Orm

Rangka kerja seperti doktrin sering membuat graf objek di mana entiti merujuk antara satu sama lain (contohnya, pengguna ? profil). Jika tidak diuruskan dengan teliti, ini boleh membentuk kitaran.

Penyelesaian:

• Gunakan __destruct() untuk memecahkan rujukan.
• Atau bergantung pada unit kerja doktrin untuk menguruskan kitar semula objek dan rujukan yang jelas selepas siram.

 fungsi prosesuser () {
    $ users = $ entityManager-> getRepository (user :: class)-> findAll ();
    foreach ($ pengguna sebagai pengguna $) {
        // proses ...
    }
    $ entityManager-> clear (); // lepaskan semua objek
    gc_collect_cycles (); // Bersihkan sebarang kitaran berlarutan
}

Kesimpulan

Koleksi sampah PHP adalah sistem hibrid:

• Pengiraan rujukan mengendalikan kebanyakan pembersihan memori dengan serta -merta.
• Langkah -langkah GC Cyclic untuk membersihkan rujukan bulat, tetapi hanya apabila perlu.

Walaupun kebanyakan pemaju tidak perlu memikirkannya semasa kitaran permintaan web biasa, memahami mekanisme ini menjadi kritikal apabila membina aplikasi PHP yang lama atau berurusan dengan graf objek kompleks.

Takeaway utama? PHP mempunyai pemungut sampah -tetapi ia bukan GC mengesan tradisional seperti di Java atau pergi. Ia adalah penyelesaian yang disasarkan untuk kitaran, bekerja di atas pengiraan rujukan.

Oleh itu, semasa anda boleh mempercayai PHP untuk membersihkannya sendiri, menyedari rujukan bulat dan menggunakan alat seperti gc_status() dan gc_collect_cycles() memberi anda kawalan yang lebih baik apabila diperlukan.

Pada asasnya: Pengiraan Rujukan melakukan pengangkat berat, dan GC adalah krew pembersihan untuk kes -kes kelebihan.

Atas ialah kandungan terperinci Menyelam jauh ke dalam mekanisme pengumpulan sampah dalaman PHP. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!