Java garbage collector-Quand collecte-t-il?

• Cela dépend de la manière dont le programme JIT a été compilé.
• De l'extérieur, nous ne pouvons pas vraiment dire quand il fonctionnera.
• Il suit un algorithme qui dépend de ce GC particulier.
• La machine virtuelle Java s'exécute sur la machine cliente avec une certaine mémoire virtuelle en cas de défaut de Windows est de 4 Go. Cela dépend également de cette mémoire virtuelle libre à ce moment précis.

Vous pouvez essayer ce petit programme pour vérifier le comportement de GC

public class GCTest {

   final int NELEMS = 50000;

   void eatMemory() {

      int[] intArray = new int[NELEMS];

      for (int i=0; i<NELEMS; i++) {
        intArray[i] = i;
      }

   }

   public static void main (String[] args) {

      GCTest gct = new GCTest();

      // Step 1: get a Runtime object
      Runtime r = Runtime.getRuntime();

      // Step 2: determine the current amount of free memory
      long freeMem = r.freeMemory();
      System.out.println("free memory before creating array: " + freeMem);

      // Step 3: consume some memory
      gct.eatMemory();

      // Step 4: determine amount of memory left after consumption
      freeMem = r.freeMemory();
      System.out.println("free memory after creating array:  " + freeMem);

      // Step 5: run the garbage collector, then check freeMemory
      r.gc();
      freeMem = r.freeMemory();
      System.out.println("free memory after running gc():    " + freeMem);
   }
}

Sortie possible May Mai être différent dans votre cas,

free memory before creating array: 4054912
free memory after creating array:  3852496
free memory after running gc():    4064184

Vérifier ce lien http://www.devdaily.com/java/edu/pj/pj010008/

Cela dépend beaucoup du garbage collector que vous utilisez réellement, de la façon dont il est réglé et de beaucoup d'entrées.

Pour une descente du Garbage Collector HotSpot (le plus commun qui vient avec Java) et comment il est réglé, vous pouvez consulter ce lien

Cela dépend complètement de la JVM réelle et de ce qu'elle choisit de faire, et est fondamentalement hors de vos mains en tant que programmeur. Les experts die-hard Greybearded peuvent vouloir dire à la JVM qu'ils connaissent mieux, mais pour les simples mortels, cela devrait être considéré comme de la magie noire mieux laissée seule.

Ce qui devrait vous préoccuper, c'est s'il peut suivre le taux de création et d'élimination des objets par vos programmes. Sinon, votre programme entier est arrêté pendant le nettoyage global. Que il s'avère que les temps de réponse sont très mauvais, mais cela arrive rarement pour les JVM modernes sur les ordinateurs modernes.

Si vous êtes curieux de savoir ce qui se passe dans votre programme et quand, alors étudiez l'outil "jvisualvm" dans les versions récentes du JDK Java 6. Il est vraiment idéal pour jeter un oeil à l'intérieur.

Le garbage collector s'exécute quand il a besoin de ressources et sur une base régulière que vous pouvez influencer en disant quand est un bon moment pour passer CPU sur la collecte, en utilisant Système.gc()

Vous pouvez aider le garbage collector en annulant explicitement les références, par exemple en donnant à vos objets init() des méthodes qui allouent des ressources et cleanup() des méthodes qui nettoient explicitement ces ressources et annulent leurs références. En annulant les références vous même vous empêchez tye garbage collector d'avoir à trouver des clusters d'obects qui ont plus de chemins vers une racine.

Lorsque la JVM n'a pas d'espace mémoire nécessaire pour s'exécuter, garbage collector s'exécute et supprime les objets inutiles et alloue de la mémoire à la JVM.

Les objets inutiles sont les objets qui n'ont pas de référence (adresse) pour cela.

Il y a principalement 4 points pour les objets éligibles au garbage collector.

1. Null Référencement

   Garbage collector peut supprimer un objet lorsque la variable de référence de l'objet est attribué null comme il est valeur

       A a = new A();
       a = null;
   

2. Réaffectation de

   Lorsqu'un autre objet est affecté à la variable de objet l'ancien objet référencé peut être supprimé par garbage collecteur.

     A a = new A(100);
     a =new A(200);
   

3. Portée locale

   Si un objet est créé à l'intérieur d'un bloc, cet objet est éligible garbage collector à côté de ce bloc.

     if(condition){
   
        A a = new A();
   
     }
   

4. Isolement

   Un objet peut faire référence à un autre objet mais il doit y en avoir au moins un référence (adresse) variable pour ces objets dans la pile, sinon tous ces objets sont éligibles pour garbage collector.

         class A{
               A r;
               A(int i){
                //something   
              }
         } 
   
         A a1 = new A(100);
         a1.r = new A(101);
         a1.r.r = new A(102);
         a1.r.r.r = a1;
   
         a1  = null //all ojects are eligible to garbage collector