Que sont le tas et la pile en Java

Comment les programmes Java s'exécutent

Les programmes Java s'exécutent dans la machine virtuelle Java (JVM) La JVM fournit un gestionnaire pour toutes les ressources requises par l'application Java lors de son exécution. Cela signifie que les applications écrites ou créées par les développeurs n'ont pas la capacité d'obtenir directement les ressources système (qu'elles soient matérielles ou logicielles) à moins que la JVM ne puisse fournir ces ressources. Ainsi, en Java, la séquence d'exécution du programme est la suivante :

La couche JVM permet à la plate-forme Java de s'exécuter de manière indépendante. D'autres langages de programmation, tels que C/C++, n'utilisent rien de similaire à la couche JVM, ils le font donc. ne sont pas des langages multiplateformes, même s'il s'agit de langages portables. Ils ressemblent à l'image ci-dessous :

Les deux formes ont des avantages et des inconvénients, et Java possède déjà son propre écosystème. Dans le même temps, les langages de programmation comme C/C++ ont un accès direct aux ressources système, ce qui est plus propice à l'optimisation de l'utilisation des unités de base, ce qui donne lieu à des programmes ultra-rapides et efficaces. Mais les deux ont leur utilité dans le monde du développement de logiciels.

Tous les langages de programmation présentent de nombreuses similitudes dans le processus de compilation et d'exécution. Le point le plus important est la gestion de la mémoire. Quel que soit le langage utilisé, la gestion de la mémoire a un impact important sur l'efficacité globale du programme, car ce n'est qu'en gérant bien les ressources mémoire que les performances de l'application peuvent être bien gérées.

Mémoire d'exécution en Java

La plate-forme sous-jacente fournit la mémoire requise par l'application, ce qui est une situation courante parmi les applications, permettant à chaque application de fonctionner de manière optimale. En Java, le système d'exploitation nécessite une autorisation pour utiliser les ressources mémoire fournies par la JVM. En Java, la mémoire JVM est divisée en 5 parties principales, dont la zone de méthode, le tas, la pile, le registre PC et la pile de méthodes locale.

Cet article se concentre principalement sur le tas et la pile. La mémoire n'est pas une feuille de papier vierge. Les programmeurs ne peuvent pas écrire des données à volonté. Elle doit être structurée avant utilisation. La pile et le tas sont des structures de données suivies lors de l'utilisation de la mémoire. Lors de l'exécution d'un programme, les données stockées sont utilisées à diverses fins, en fonction de l'objectif du programme.

La JVM détermine la zone de données d'exécution utilisée lors de l'exécution du programme. Certaines zones de données dépendent de la JVM, ce qui signifie qu'elles sont créées au démarrage de la JVM et persistent tout au long du cycle de vie de la JVM. Cependant, chaque thread crée et détruit d’autres zones de données. La JVM peut exécuter plusieurs threads d'exécution en même temps, ce qui signifie que chaque thread possède son propre PC (compteur de programme, compteur de programme) pour maintenir la position de l'instruction en cours d'exécution, et un cadre de pile pour enregistrer l'allocation de mémoire statique.

Pile

Une pile est une structure en mémoire dans laquelle les développeurs stockent les éléments de manière à permettre aux données d'être récupérées uniquement à partir du haut de la pile - souvent appelée premier entré, dernier sorti (FILO ou LIFO). Chaque thread possède une pile JVM privée qui stocke les variables liées à l'allocation de mémoire statique. En fait, dans les méthodes déclarées et utilisées dans notre code, des variables primitives spécifiques sont stockées dans la zone de pile. De plus, les références aux objets réellement stockés dans la mémoire tas sont également stockées dans la zone de pile. Par conséquent, toute mémoire allouée localement est stockée sur la pile.

La taille par défaut de la mémoire de la pile peut être modifiée à l'aide du paramètre JVM -Xss. Parfois, la pile peut déborder si trop de variables sont allouées ou si une méthode s'appelle de manière récursive. Une erreur courante connue de tous les programmeurs Java est Java.lang.stackoverflowerror, qui s'affiche lorsque la mémoire de la pile est insuffisante. Chaque appel de méthode en Java alloue une partie de la mémoire sur la pile. Par conséquent, des appels de méthode récursifs mal conçus peuvent facilement occuper toute la mémoire de la pile et provoquer des erreurs de dépassement de mémoire. Java.lang.stackoverflowerror，当栈内存不足时提示该错误。Java中的每个方法调用都会在栈中分配一块内存，因此，设计糟糕的递归方法调用很容易占用所有栈内存，导致栈内存溢出错误。

堆

堆是JVM一启动就创建的内存区域，它会一直存在，直到JVM被销毁。与栈不同的是，栈是单个线程的属性(因为每个线程都有自己的栈)，堆实际上是由JVM本身管理的全局内存，此内存在运行时用于为对象分配内存。因此，对象的实例化可以是用户定义的类、JDK或其他库类。简而言之，使用new关键字创建的任何对象都存储在堆内存中。堆内存中的对象可被JVM运行的所有线程访问。访问管理非常复杂，使用了非常复杂的算法，这就是JVM垃圾收集器发挥作用的地方。

堆的默认大小可以使用JVM参数-Xms和-Xmx来更改。随着对象的创建和销毁，堆的大小也会增加或减少，如果达到最大内存限制后并尝试进一步分配内存，则抛出java.lang.OutOfMemoryError

Heap🎜🎜Le tas est une zone mémoire créée au démarrage de la JVM. Elle existera jusqu'à la destruction de la JVM. Contrairement à la pile, qui est une propriété d'un seul thread (car chaque thread a sa propre pile), le tas est en fait une mémoire globale gérée par la JVM elle-même, et cette mémoire est utilisée pour allouer de la mémoire aux objets au moment de l'exécution. Par conséquent, l'instanciation de l'objet peut être une classe définie par l'utilisateur, un JDK ou une autre classe de bibliothèque. En bref, tout objet créé à l'aide du mot-clé new est stocké dans la mémoire tas. Les objets dans la mémoire tas sont accessibles par tous les threads exécutés dans la JVM. La gestion des accès est très complexe et utilise des algorithmes très complexes, et c'est là que le garbage collector JVM entre en jeu. 🎜🎜La taille par défaut du tas peut être modifiée à l'aide des paramètres JVM -Xms et -Xmx. Au fur et à mesure que les objets sont créés et détruits, la taille du tas augmente ou diminue également. Si la limite maximale de mémoire est atteinte et qu'une allocation supplémentaire de mémoire est tentée, java.lang.OutOfMemoryError est renvoyé. 🎜

String Pool (StringPool) dans le tas

La classe Java.lang.String est la classe la plus utilisée en Java, une attention particulière doit donc être accordée à son efficacité. Par rapport aux types de données de base, l'efficacité opérationnelle des chaînes est toujours très lente. Par conséquent, il faut utiliser un moyen pour rendre l'efficacité et la commodité des opérations sur les objets chaîne similaires ou proches des types de données de base. tas Une zone mémoire spéciale (StringPool) est allouée dans la JVM et tous les objets chaîne créés sont stockés dans le StringPool par la JVM. Cela améliore les performances par rapport aux autres objets créés dans le tas. Java.lang.String类是Java中使用最多的类，因此，应该特别注意它的效率问题。与基本数据类型相比，字符串的操作效率总是很慢，所以，必须采用某种方式使得字符串对象操作的效率和便利性方面类似或者接近于基本数据类型，为了达到这个目的就在堆中分配了一块特殊内存区域(StringPool)，创建的任何字符串对象都由JVM存储在StringPool中。与堆中创建的其他对象相比，这提高了性能。

从代码示例说明堆和栈

为了更好地说明在Java中堆和栈内存的使用，让我们写一个简单的程序，并决定哪个分配分配到哪个内存——堆或栈:

public class HeapAndStackTest {
    public static void main(String[] args) {
        int x=10;
        int y=20;
        String greet = "Hello";
        Date d = new Date();
        diff(x, y);
    }

    public static int diff(int x1, int x2) {
        return x2-x1;
    }
}

这段代码运行方式如下：

• 程序启动，JVM将Java运行时环境(JRE)类加载到堆中。

• 在遇到main() 方法时，会创建一个栈帧。

• 局部变量x和y存储在栈中。

• 字符串greet分配在堆的StringPool区域中。

• Date对象分配在堆区，而它的引用d

  Tas et pile expliqués à partir d'exemples de code

  Pour mieux expliquer l'utilisation de la mémoire de tas et de pile en Java, écrivons un programme simple et décidons quelle allocation est allouée à quelle mémoire—&mdash ;Tas ou pile :
rrreee

Ce code s'exécute comme suit :

• Le programme démarre et la JVM charge la classe Java Runtime Environment (JRE) dans le tas. 🎜
• 🎜Lorsque vous rencontrez la méthode main(), un cadre de pile sera créé. 🎜🎜
• 🎜Les variables locales x et y sont stockées sur la pile. 🎜🎜
• 🎜La chaîne greet est allouée dans la zone StringPool du tas. 🎜🎜
• 🎜L'objet Date est alloué dans la zone du tas, et sa référence d est stockée dans la pile. 🎜🎜🎜🎜🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!