Hai! Saya fikir anda tidak akan terkejut jika saya memberitahu anda bahawa komputer anda mempunyai jumlah memori yang terhad :)
Malah cakera keras anda (yang bersaiz berkali-kali ganda daripada RAM) boleh menjadi sesak dengan permainan kegemaran anda, rancangan TV dan perkara lain. Untuk mengelakkan ini daripada berlaku, anda perlu memantau keadaan semasa memori komputer anda dan memadam fail yang tidak diperlukan. Bagaimanakah semua ini berkaitan dengan pengaturcaraan Java? Secara langsung! Lagipun, mencipta sebarang objek menyebabkan mesin Java memperuntukkan memori untuknya . Program dunia sebenar yang besar mencipta puluhan atau ratusan ribu objek, dan sebahagian memori diperuntukkan untuk setiap satu daripadanya. Tetapi apa yang anda fikir, berapa banyak objek ini wujud? Adakah mereka "hidup" sepanjang program kami berjalan? Sudah tentu tidak. Walaupun dengan semua kelebihannya, objek Java tidak kekal :) Objek mempunyai kitaran hayatnya sendiri. Hari ini kita akan berehat sedikit daripada menulis kod dan meneroka proses ini :) Ia juga sangat penting untuk memahami cara program berfungsi dan untuk mengurus sumber. Jadi, di manakah kehidupan objek bermula? Seperti manusia sejak lahir iaitu ketika ia dicipta.
Pertama, mesin maya Java memperuntukkan memori yang diperlukan untuk mencipta objek. Kemudian ia mencipta rujukan kepadanya (dalam kes kami, cat) untuk membolehkan ia menjejakinya. Kemudian semua pembolehubah dimulakan, pembina dipanggil, dan objek segar kami kini menjalani kehidupannya sendiri :) Jangka hayat objek berbeza-beza. Tiada angka yang tepat di sini. Dalam apa jua keadaan, objek hidup dalam program dan melaksanakan fungsinya untuk beberapa tempoh masa. Tepatnya, objek itu "hidup" selagi terdapat rujukan kepadanya. Sebaik sahaja tiada rujukan, objek "mati". Sebagai contoh:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
lamborghini = null;
}
}
Dalam main()kaedah itu, objek Kereta "Lamborghini Diablo" tidak lagi hidup pada baris kedua. Terdapat hanya satu rujukan kepadanya, dan rujukan itu ditetapkan kepada null. Oleh kerana tiada lagi rujukan kepada Diablo, ia menjadi "sampah". Rujukan tidak perlu ditetapkan kepada sifar untuk ini berlaku:
public class Car {
String model;
public Car(String model) {
this.model = model;
}
public static void main(String[] args) {
Car lamborghini = new Car("Lamborghini Diablo");
Car lamborghiniGallardo = new Car("Lamborghini Gallardo");
lamborghini = lamborghiniGallardo;
}
}
Di sini kami telah mencipta objek kedua dan menetapkannya kepada rujukan lamborghini. Kini dua rujukan menunjuk kepada Lamborghini Gallardoobjek, tetapi Lamborghini Diabloobjek itu tidak mempunyai apa-apa. Ini bermakna Diabloobjek itu menjadi sampah. Ini adalah apabila pengumpul sampah (GC) terbina dalam Java bermula.
Pengumpul sampah ialah mekanisme Java dalaman yang bertanggungjawab untuk membebaskan memori, iaitu mengeluarkan objek yang tidak diperlukan daripada ingatan. Terdapat sebab mengapa kami memilih untuk mewakilinya dengan pembersih vakum robot. Pengumpul sampah berfungsi dengan cara yang hampir sama: ia "menggerakkan" program anda di latar belakang, mengumpul sampah. Anda boleh dikatakan tidak perlu berinteraksi dengannya. Tugasnya adalah untuk memadam objek yang tidak lagi digunakan dalam program. Oleh itu, ia membebaskan memori untuk objek lain. Adakah anda masih ingat bahawa pada permulaan pelajaran yang kami katakan dalam kehidupan sebenar anda perlu memantau keadaan komputer anda dan memadam fail lama? Jika kita bercakap tentang objek Java, pengumpul sampah melakukan ini untuk anda. Pengumpul sampah dimulakan berkali-kali semasa program anda berjalan: anda tidak perlu memanggilnya secara eksplisit dan memberinya arahan (walaupun ini secara teknikalnya mungkin). Kami akan bercakap lebih lanjut mengenai pemungut sampah kemudian dan menganalisis cara ia berfungsi dengan lebih terperinci. Apabila pemungut sampah mencapai objek—sejurus sebelum ia dimusnahkan—kaedah khas objek itu finalize()dipanggil. Kaedah ini boleh digunakan untuk mengeluarkan sumber tambahan tertentu yang digunakan oleh objek. Kaedah ini finalize()tergolong dalam kelas Objek. Dalam erti kata lain, ia serupa dengan equals(), hashCode()dan toString()(yang pernah anda temui sebelum ini). Setiap objek mempunyainya . Ia berbeza daripada kaedah lain dalam hal itu...bagaimana kita harus mengatakan ini...ia sangat disengajakan. Itu yang kami maksudkania tidak selalu dipanggil sebelum objek dimusnahkan . Pengaturcaraan adalah aktiviti yang sangat tepat. Pengaturcara memberitahu komputer untuk melakukan sesuatu, dan komputer melakukannya. Saya menganggap anda telah terbiasa dengan tingkah laku seperti ini, jadi pada mulanya mungkin sukar untuk anda menerima idea berikut: "Sebelum objek dimusnahkan, kaedah kelas Objek dipanggil. Atau tidak. finalize()Jika kita bernasib baik! " Namun, ini adalah realiti. Mesin Java sendiri menentukan sama ada untuk memanggil finalize() berdasarkan kes demi kes. Sebagai percubaan, mari cuba jalankan kod berikut:
public class Cat {
private String name;
public Cat(String name) {
this.name = name;
}
public Cat() {
}
public static void main(String[] args) throws Throwable {
for (int i = 0 ; i < 1000000; i++) {
Cat cat = new Cat();
cat = null;// The first object becomes available for garbage collection here
}
}
@Override
protected void finalize() throws Throwable {
System.out.println("The Cat is destroyed!");
}
}
Kami mencipta Catobjek, dan dalam baris seterusnya kami mengeluarkan satu-satunya rujukan kepadanya. Dan kami melakukannya berjuta kali. Kami telah mengatasi finalize()kaedah tersebut dengan jelas. Setiap kali Catobjek dimusnahkan, ia mesti memaparkan rentetan—sebanyak satu juta kali. Tetapi tidak! Tepatnya, pada komputer saya ia dilaksanakan hanya 37346 kali! Dalam erti kata lain, mesin Java saya memutuskan untuk memanggil finalize()kaedah hanya dalam 1 daripada setiap 27 kes. Dalam kes lain, kutipan sampah tidak melibatkan panggilan ini. Cuba jalankan kod ini sendiri. Anda berkemungkinan besar akan mendapat hasil yang berbeza. Seperti yang anda lihat, sukar untuk menghubungi finalize()rakan kongsi yang boleh dipercayai :) Jadi, inilah petua kecil untuk masa hadapan: jangan bergantung pada finalize()kaedah untuk mengeluarkan sumber kritikal.JVM mungkin memanggilnya, atau mungkin tidak. Siapa tahu? Jika objek anda memegang beberapa sumber kritikal prestasi (contohnya, sambungan pangkalan data terbuka) semasa ia masih hidup, adalah lebih baik untuk mencipta dan secara eksplisit memanggil kaedah khas untuk melepaskannya apabila objek tidak lagi diperlukan. Dengan cara itu, anda akan tahu dengan pasti bahawa prestasi program anda tidak akan terjejas. Kami bermula dengan mengatakan bahawa bekerja dengan ingatan dan pengumpulan sampah adalah topik yang sangat penting, dan memang begitu. Salah pengendalian sumber dan salah faham bagaimana objek yang tidak perlu dibersihkan boleh membawa kepada salah satu pepijat yang paling tidak menyenangkan: kebocoran memori . Ini adalah salah satu ralat pengaturcaraan yang paling terkenal. Ia juga mempunyai artikel Wikipedianya sendiri. Kod yang ditulis dengan buruk boleh mencipta situasi di mana memori diperuntukkan setiap kali untuk objek yang baru dibuat, tetapi objek lama yang tidak diperlukan tidak tersedia untuk pengumpulan sampah. Memandangkan kami telah pun membuat analogi pembersih vakum robot, bayangkan apa yang akan berlaku jika sebelum menjalankan robot anda menabur stoking di seluruh rumah, memecahkan pasu kaca dan meninggalkan kepingan Lego di seluruh lantai. Sememangnya, robot itu akan cuba melakukan sesuatu, tetapi suatu hari nanti ia akan merampas.
Untuk pembersih vakum berfungsi dengan baik, anda perlu memastikan lantai dalam bentuk yang baik dan mengambil semua yang tidak dapat dikendalikannya. Pengumpul sampah mengikut prinsip yang sama. Jika program mempunyai banyak objek yang tidak dapat dibersihkan (seperti stoking atau Lego untuk pembersih vakum robotik kami), suatu hari nanti kami akan kehabisan ingatan. Bukan sahaja program anda akan hang, semua program lain yang berlaku pada komputer juga akan. Lagipun, mereka juga tidak akan mempunyai ingatan yang mencukupi (berbalik kepada analogi kita, kaca pecah di lantai menghentikan bukan sahaja pembersih vakum, tetapi juga orang yang tinggal di rumah). Ringkasnya, ini adalah rupa kitaran hayat objek dan pengumpulan sampah di Jawa. Anda tidak perlu menghafal ini: cukup sekadar memahami cara ia berfungsi. Dalam pelajaran seterusnya, kita akan kembali kepada proses ini dengan lebih terperinci. Tetapi buat masa ini, anda boleh kembali menyelesaikan tugas CodeGym :) Semoga berjaya!
GO TO FULL VERSION