Discussion :

[zlaptop]

Bonjour,

une petite question : supposons un programme Java, dans lequel j'implémente une classe "maClasse". Supposons aussi que pour une raison quelconque je souhaite connaitre le nombre d'instance de ma classe. Bien entendu je n'ai pas envie d'avoir un compteur manuel que j'incrémente et décrémente moi même au grès des créations / suppressions des instances de maClasse (typiquement dans des boucle for, etc.). Je pensais donc "simplement" mettre dans maClasse un attribut nbInstance :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
static int nbInstance ;

et dans les constructeurs de maClasse, j'incrémente nbInstance. Voila qui permet de suivre le nombre de créations d'instances de maClasse sans intervention particulière...reste à prendre en compte les suppressions. J'ai pensé faire le symétrique (décrémenter nbInstance à chaque appel à un 'destructeur'), seulement y-a-t-il des destructeurs en Java ? Je me suis rapidement rendu compte que "finalize" n'en était pas un (au sens C++ du terme). Comment faire donc ?

Merci pour votre aide !

[thelvin]

J'ai pensé faire le symétrique (décrémenter nbInstance à chaque appel à un 'destructeur'), seulement y-a-t-il des destructeurs en Java ? Je me suis rapidement rendu compte que "finalize" n'en était pas un (au sens C++ du terme). Comment faire donc ?

En effet finalize() n'est pas un destructeur et il n'y a pas de destructeur en Java.

Ce n'est pas vraiment possible de faire quelque chose de ce genre en Java. À la place, il te faudrait :

- Soit un autre mécanisme d'enregistrement/déregistrement d'instances, à la création et appelé chaque fois que ton code décide "cette instance-là, on s'en servira plus"
- Soit en faisant avec finalize() quand même, en sachant que même après l'appel à finalize(), l'instance peut quand même être là quelque part pendant un temps arbitrairement long.
- Soit avec des outils de profiling spécialisés pour mesurer ce qui t'intéresse vraiment, ce qui, je suppose, n'est pas le nombre d'instances en cours de telle ou telle classe, mais le temps passé dans tel bout de code ou l'utilisation mémoire causée par quoi.

[tchize_]

pourquoi finalize ne te conviens pas?

[CyberChouan]

En effet finalize() n'est pas un destructeur et il n'y a pas de destructeur en Java.

finalize() n'est pas un destructeur, mais c'est une méthode qui est automatiquement appelée lorsque ta JVM décide de détruire l'objet.

Tu ne dois pas l'appeler explicitement (cela fausserait ton comptage car ça n'assurerait pas la destruction de l'instance), mais tu peux t'en servir.

Par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class TestComptage {
 
    private static int nbInstance = 0;
 
    private static final Object lock = new Object();
 
    public TestComptage() {
        synchronized(lock) {
            nbInstance++;
        }
    }
 
    public void finalize() {
        synchronized(lock) {
            nbInstance--;
        }
    }
 
    public static void main(String[] args) {
        TestComptage tc1 = new TestComptage();
        TestComptage tc2 = new TestComptage();
        TestComptage tc3 = new TestComptage();
 
        System.out.println(TestComptage.nbInstance);
 
        tc2 = null; // un objet n'est plus référencé et pourra être détruit
        tc3 = tc1; // un autre objet n'est plus référencé et pourra être détruit
 
        System.gc();
 
        try {
            // Pour laisser au GC le temps d'être effectivement exécuté
            Thread.sleep(3000);
        } catch (InterruptedException ie) {
        }
 
        System.out.println(TestComptage.nbInstance);
    }
}

A la construction d'un objet, le compteur d'instances est incrémenté.
Quand la JVM décide de détruire l'objet, elle appelle finalize() avant ce qui assure normalement la décrémentation du compteur.

Maintenant, si tu veux "forcer" la JVM a détruire les instances qui ne sont plus référencées, tu peux tenter d'invoquer explicitement le "garbage collector" par "System.gc();".

Attention :
- cette commande n'assure pas que le GC sera lancé immédiatement
- elle n'assure pas non plus que les objets seront réellement détruits
- lancer manuellement le GC est généralement une mauvaise pratique qui n'est utilisée qu'à des fins de test !!!

[zlaptop]

Merci pour vos réponses. Effectivement finalize() n'est pas adaptée puisque ça ne maintiendra pas exactement le compteur à jour.

Finalement si je comprend bien il n'y a donc pas vraiment d'autre façon que de faire ça "à la main"...

- Soit avec des outils de profiling spécialisés pour mesurer ce qui t'intéresse vraiment, ce qui, je suppose, n'est pas le nombre d'instances en cours de telle ou telle classe, mais le temps passé dans tel bout de code ou l'utilisation mémoire causée par quoi.

À vrai dire il s'agissait plus d'une question théorique que je me posais, sans application réelle.

[tchize_]

sans application réelle.

on est d'accord là dessus

[professeur shadoko]

À vrai dire il s'agissait plus d'une question théorique que je me posais, sans application réelle.

bien que ça soit un peu lourd pour ton besoin ça c'est du ressort des références faibles et des queues de références ... (mais bon c'est une question théorique hein!). remarque: à la fin il peut rester des objets non récupérés par le GC mais bon on n'a plus besoin du compte dans ce cas.

[thebloodyman]

Finalement si je comprend bien il n'y a donc pas vraiment d'autre façon que de faire ça "à la main".

Avec le langage Java pure, oui et sans aucune garantie.

Maintenant, certaines apis tierces te permettent de dépasser les limites du langage.
Par exemple, si tes instances sont gérées (donc créer et supprimer) et utilisables depuis une couche de plus haut niveau comme la factory d'objets du framework Spring, tu peux arriver sans mal à tes fins avec les listeners prévues.

[merill]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
public class TestComptage {
 
    private static int nbInstance = 0;
 
    private static final Object lock = new Object();
 
    public TestComptage() {
        synchronized(lock) {
            nbInstance++;
        }
    }
 
    public void finalize() {
        synchronized(lock) {
            nbInstance--;
        }
    }
 
    public static void main(String[] args) {
        TestComptage tc1 = new TestComptage();
        TestComptage tc2 = new TestComptage();
        TestComptage tc3 = new TestComptage();
 
        System.out.println(TestComptage.nbInstance);
 
        tc2 = null; // un objet n'est plus référencé et pourra être détruit
        tc3 = tc1; // un autre objet n'est plus référencé et pourra être détruit
 
        System.gc();
 
        try {
            // Pour laisser au GC le temps d'être effectivement exécuté
            Thread.sleep(3000);
        } catch (InterruptedException ie) {
        }
 
        System.out.println(TestComptage.nbInstance);
    }
}

Autant mettre des opérations atomique, c'est plus rapide.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class TestComptage {
 
    private static AtomicInteger nbInstance = new AtomicInteger(0);
 
    private static final Object lock = new Object();
 
    public TestComptage() {
            nbInstance.increment();
    }
 
    public void finalize() {
            nbInstance.decrement();
    }
 
}