Explication graphique détaillée du mécanisme de mémoire de Java (avec code)

Java divise la mémoire en deux types : l'un est la mémoire de pile et l'autre est la mémoire de tas. Certaines variables de typede base et objetréférencevariables définies dans la fonction sont toutes dans la pile mémoire de la fonction Allocation, Lorsqu'une variable est définie dans un bloc de code, Java alloue de l'espace mémoire pour la variable sur la pile. Lorsque la portée de la variable est dépassée (par exemple, en appelant la fonction B dans la fonction A , définissez la variable. a dans la fonction B. La portée de la variable a est uniquement la fonction B. Une fois la fonction B exécutée, la variable a sera automatiquement détruite (la mémoire qui lui est allouée sera recyclée) et Java libérera automatiquement l'espace mémoire. alloué à la variable et l'espace mémoire peut être utilisé immédiatement à d'autres fins.

　

La mémoire du tas est utilisée pour stocker la mémoire créée par le nouveauArray, la mémoire allouée dans le tas, automatiquement détruite par le recycleur de la machine virtuelle Java à gérer. Après avoir généré un tableau ou un objet dans le tas, vous pouvez également définir une variable spéciale dans la pile, de sorte que la valeur de la variable dans la pile soit égale à la première adresse du tableau ou de l'objet dans la mémoire du tas. La variable dans la pile Elle devient une variable de référence du tableau ou de l'objet. À l'avenir, vous pourrez utiliser les variables de la pile pour accéder au tableau ou à l'objet dans le tas dans le programme. au tableau ou à l'objet. Les variables de référence sont des variables ordinaires qui sont allouées sur la pile lorsqu'elles sont définies. Les variables de référence sont libérées après l'exécution du programme en dehors d'autres portées. Les tableaux et les objets sont alloués dans le tas Même si le programme s'exécute en dehors du bloc de code où se trouve l'instruction tableau ou objet générée par new, la mémoire occupée par le tableau et l'objet ne sera pas libérée. Les tableaux et les objets deviennent des déchets lorsqu'aucune variable de référence ne pointe vers eux et ne peuvent plus être utilisés. Ils sont collectés (libérés) par le garbage collector à un moment indéterminé ultérieurement. C'est aussi la raison pour laquelle Java occupe plus de mémoire. En fait, les variables de la pile pointent vers les variables de la mémoire tas Il s'agit d'un pointeur en Java.

Exemple de code Démo1 : Création d'un objet unique

class Person {
    String name ;
    int age ;
    public void tell() {
        System.out.println("姓名："+name+",年龄:"+age);
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Person per = new Person() ;
    }
}

Dans le programme ci-dessus, un objet par est instancié Pendant le processus d'instanciation, il est nécessaire. pour créer de l'espace dans la mémoire, qui comprend la mémoire de pile et la mémoire de tas. L'allocation de mémoire spécifique est comme indiqué dans la figure ci-dessous :

Figure 1. -1 Objet Le processus d'instanciation

Nous pouvons constater à partir de la figure ci-dessus que le nom de l'objet per est enregistré dans la mémoire de la pile (

Plus précisément, il est enregistré dans la mémoire de la pile est l'adresse d'accès à l'espace mémoire du tas ), et le contenu spécifique de l'objet, tel que les attributs nom et âge, sont stockés dans la mémoire du tas. Étant donné que l'objet per a uniquement été instancié et qu'aucune valeur spécifique ne lui a été attribuée, il a des valeurs par défaut. La valeur par défaut de string est null et la valeur par défaut du type int est 0. Comme mentionné précédemment, l'espace mémoire du tas doit être ouvert à l'aide du nouveau mot-clé.

Exemple de code Démo2 : Création d'objets multiples

class Person {
    String name ;
    int age ;
    public void tell() {
        System.out.println("姓名："+name+",年龄:"+age);
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Person per1 = new Person() ;
        Person per2 = new Person() ;
        per1.name="张三" ;
        per1.age=30 ;
        per2.age=33 ;
        per1.tell(); 
        per2.tell(); 
        
    }
}

　　　　　　 Figure 1-2 Instancier deux objets

Concept clé : les classes, comme les tableaux, sont des types de référence qui font référence à la même mémoire de tas pointée par plusieurs piles. souvenirs, jetons un coup d'œil à un exemple simple de passage de référence.

Exemple de code Démo3 : Transfert de référence d'objet 1

class Person {
    String name ;
    int age ;
    public void tell() {
        System.out.println("姓名："+name+",年龄:"+age);
    }
}

public class Demo3 {
    public static void main(String[] args) {
        Person per1 = new Person() ;
        Person per2 = per1 ;//-------注意--------
        per1.name="张三" ;
        per1.age=30 ;
        per2.age=33 ;
        per1.tell(); 
        per2.tell(); 
        
    }
}

Le résultat de l'exécution du programme est :

D'après les résultats d'exécution du programme, nous pouvons constater que

le contenu de sortie des deux objets est le même. En fait, ce qu'on appelle le transfert de référence consiste à transférer les droits d'utilisation d'un espace mémoire tas vers. plusieurs espaces mémoire de pile. Chaque espace mémoire de pile Vous pouvez modifier le contenu de l'espace mémoire du tas Le schéma d'allocation de mémoire de ce programme est le suivant : .

　　　　　　　　　 图1-3 对象引用的传递内存分配

　　　　　　　　　 图1-3 对象引用的传递内存分配(续)

注意:上述实例中对象per2没有堆内存空间，这是因为对象per2只进行声明操作，也没有进行实例化操作。只是使用new关键字，实例化以后才会有堆内存空间

代码实例Demo4:对象引用传递2

class Person {
    String name ;
    int age ;
    public void tell() {
        System.out.println("姓名："+name+",年龄:"+age);
    }
}

public class Demo4 {
    public static void main(String[] args) {
        Person per1 = new Person() ;
        Person per2 = new Person() ;
        per1.name="张三" ;
        per1.age=30 ;
        per2.name="李四" ;
        per2.age=33 ;
        
        per2=per1 ;//-----注意----
        
        per1.tell(); 
        per2.tell(); 
        
    }
}

 上述运行程序结果为:

从程序的输出结果可以发现跟Demo3差不多。不过内存分配发生了一些变化，具体如下所示:

　　　　　　　　　　　 图1-4 (垃圾对象)的产生

注意点:

 　　1.Java本身提供垃圾收集机制(Garbage Collection,GC),会不定期释放不用的内存空间，只要对象不用了，就会等待GC释放空间，如上面堆内存中的name="李四";age=33。

　　2.一个栈内存只能指向一个堆内存空间，如果要想指向其他堆内存空间，则必须先断开已有的指向，才能分配新的指向。

Java中常见的内存区域

在Java中主要存在4块内存空间，这些内存的名称及作用如下:

　　1.栈内存空间:保存所有对象的名称。

　　2.堆内存空间:保存每个对象的具体属性内容。

　　3.全局数据区:保存static类型的属性值。

　　4.全局代码区:保存所有的方法定义。

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!