Stack Memory dan Heap Space di Java

Pengaturcaraan

1. Pengenalan

Untuk menjalankan aplikasi dengan cara yang optimum, JVM membahagikan memori menjadi memori timbunan dan timbunan. Setiap kali kita menyatakan pemboleh ubah dan objek baru, memanggil kaedah baru, menyatakan String atau melakukan operasi yang serupa, JVM menetapkan memori untuk operasi ini dari Stack Memory atau Heap Space.

Dalam tutorial ini, kita akan membincangkan model memori ini. Kami akan memasukkan beberapa perbezaan utama di antara mereka, bagaimana ia disimpan dalam RAM, ciri yang mereka tawarkan dan di mana menggunakannya.

2. Stack Memory di Java

Stack Memory di Java digunakan untuk peruntukan memori statik dan pelaksanaan utas. Ini berisi nilai-nilai primitif yang khusus untuk suatu metode dan referensi ke objek yang ada di timbunan, yang dirujuk dari metode tersebut.

Akses ke memori ini adalah mengikut urutan Last-In-First-Out (LIFO). Setiap kali kaedah baru dipanggil, blok baru di atas tumpukan dibuat yang mengandungi nilai-nilai khusus untuk kaedah itu, seperti pemboleh ubah primitif dan rujukan ke objek.

Apabila kaedah selesai pelaksanaan, kerangka tumpukan yang sesuai dibilas, aliran kembali ke kaedah panggilan dan ruang tersedia untuk kaedah seterusnya.

2.1. Ciri-ciri Utama Stack Memory

Selain daripada apa yang telah kita bincangkan sejauh ini, berikut adalah beberapa ciri memori timbunan yang lain:

  • Ia tumbuh dan menyusut apabila kaedah baru dipanggil dan dikembalikan masing-masing
  • Pemboleh ubah di dalam timbunan hanya ada selagi kaedah yang membuatnya berjalan
  • Ia secara automatik diperuntukkan dan dialihkan ketika kaedah menyelesaikan pelaksanaan
  • Sekiranya ingatan ini penuh, Java akan membuang java.lang.StackOverFlowError
  • Akses ke memori ini cepat jika dibandingkan dengan memori timbunan
  • Memori ini selamat digunakan kerana setiap utas beroperasi dalam timbunannya sendiri

3. Tumpukan Ruang di Jawa

Ruang timbunan di Java digunakan untuk peruntukan memori dinamis untuk objek Java dan kelas JRE pada waktu runtime . Objek baru selalu dibuat di ruang timbunan dan rujukan ke objek ini disimpan dalam memori timbunan.

Objek-objek ini mempunyai akses global dan dapat diakses dari mana saja dalam aplikasi.

Model memori ini kemudian dipecah menjadi bahagian yang lebih kecil yang disebut generasi, berikut:

  1. Generasi Muda - di sinilah semua objek baru diperuntukkan dan berumur. Pengumpulan sampah kecil berlaku semasa ini diisi
  2. Generasi Lama atau Bertahan - di sinilah objek yang masih hidup disimpan. Ketika objek disimpan di Generasi Muda, ambang untuk usia objek ditetapkan dan ketika ambang itu tercapai, objek tersebut dipindahkan ke generasi lama
  3. Penjanaan Tetap - ini terdiri daripada metadata JVM untuk kelas masa dan kaedah aplikasi

Bahagian yang berbeza ini juga dibincangkan dalam artikel ini - Perbezaan Antara JVM, JRE, dan JDK.

Kita selalu dapat memanipulasi ukuran memori timbunan sesuai dengan keperluan kita. Untuk maklumat lebih lanjut, lawati artikel Baeldung yang dipautkan ini.

3.1. Ciri-ciri Utama Memori Java Heap

Selain daripada apa yang telah kita bincangkan sejauh ini, berikut adalah beberapa ciri ruang timbunan lain:

  • Ia diakses melalui teknik pengurusan memori yang kompleks yang merangkumi Generasi Muda, Generasi Tua atau Tenured, dan Generasi Kekal
  • Sekiranya ruang timbunan penuh, Java membuang java.lang.OutOfMemoryError
  • Akses ke memori ini lebih perlahan berbanding memori timbunan
  • Memori ini, berbeza dengan timbunan, tidak akan dialihkan secara automatik. Ia memerlukan Pengumpul Sampah untuk membebaskan objek yang tidak digunakan untuk menjaga kecekapan penggunaan memori
  • Tidak seperti timbunan, timbunan tidak selamat dari benang dan perlu dijaga dengan menyegerakkan kod dengan betul

4. Contoh

Berdasarkan apa yang telah kita pelajari sejauh ini, mari kita menganalisis kod Java ringkas dan mari kita menilai bagaimana memori dikendalikan di sini:

class Person { int id; String name; public Person(int id, String name) { this.id = id; this.name = name; } } public class PersonBuilder { private static Person buildPerson(int id, String name) { return new Person(id, name); } public static void main(String[] args) { int id = 23; String name = "John"; Person person = null; person = buildPerson(id, name); } }

Mari kita analisis langkah demi langkah ini:

  1. Upon entering the main() method, a space in stack memory would be created to store primitives and references of this method
    • The primitive value of integer id will be stored directly in stack memory
    • The reference variable person of type Person will also be created in stack memory which will point to the actual object in the heap
  2. The call to the parameterized constructor Person(int, String) from main() will allocate further memory on top of the previous stack. This will store:
    • The this object reference of the calling object in stack memory
    • The primitive value id in the stack memory
    • The reference variable of String argument name which will point to the actual string from string pool in heap memory
  3. The main method is further calling the buildPerson() static method, for which further allocation will take place in stack memory on top of the previous one. This will again store variables in the manner described above.
  4. However, for the newly created object person of type Person, all instance variables will be stored in heap memory.

This allocation is explained in this diagram:

5. Summary

Before we conclude this article, let's quickly summarize the differences between the Stack Memory and the Heap Space:

Parameter Stack Memory Heap Space
Application Stack is used in parts, one at a time during execution of a thread The entire application uses Heap space during runtime
Size Stack has size limits depending upon OS and is usually smaller then Heap There is no size limit on Heap
Storage Stores only primitive variables and references to objects that are created in Heap Space All the newly created objects are stored here
Order It is accessed using Last-in First-out (LIFO) memory allocation system This memory is accessed via complex memory management techniques that include Young Generation, Old or Tenured Generation, and Permanent Generation.
Life Stack memory only exists as long as the current method is running Heap space exists as long as the application runs
Efficiency Comparatively much faster to allocate when compared to heap Slower to allocate when compared to stack
Allocation/Deallocation Memori ini secara automatik dialokasikan dan dialihkan ketika kaedah dipanggil dan dikembalikan masing-masing Ruang timbunan diperuntukkan apabila objek baru dibuat dan dialihkan oleh Gargabe Collector apabila objek tidak lagi dirujuk

6. Kesimpulannya

Tumpukan dan timbunan adalah dua cara di mana Java memperuntukkan memori. Dalam artikel ini, kami memahami cara kerjanya dan kapan menggunakannya untuk mengembangkan program Java yang lebih baik.

Untuk mengetahui lebih lanjut mengenai Pengurusan Memori di Java, lihat artikel ini di sini. Kami juga membincangkan JVM Garbage Collector yang dibincangkan secara ringkas dalam artikel ini.