Comment puis-je obtenir la mémoire que mon programme Java utilise via Java Runtime api?

Vous le faites correctement. La manière d'obtenir l'utilisation de la mémoire est exactement comme vous l'avez décrit:

Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()

Mais la raison de votre programme renvoie toujours la même utilisation de la mémoire est parce que vous ne créez pas assez d'objets pour surmonter la précision des limites de la freeMemory méthode. Bien qu'il ait octet résolution, il n'y a aucune garantie pour combien de précis freeMemory doit être. La javadoc en dit autant:

une approximation de la quantité totale de mémoire actuellement disponible pour de futurs objets alloués, mesurée en octets.

Essayez la suivante, ce qui crée deux millions NewObject cas, et imprime à chaque fois le résultat de freeMemory changements:

public static void main(String[] args) {
    Runtime rt = Runtime.getRuntime();
    long prevTotal = 0;
    long prevFree = rt.freeMemory();

    for (int i = 0; i < 2_000_000; i++) {
        long total = rt.totalMemory();
        long free = rt.freeMemory();
        if (total != prevTotal || free != prevFree) {
            System.out.println(
                String.format("#%s, Total: %s, Free: %s, Diff: %s",
                    i, 
                    total,
                    free,
                    prevFree - free));
            prevTotal = total;
            prevFree = free;
        }
        map.put(i, new NewObject());
    }
}

Sur ma machine, je vois la sortie comme suit

#0, Total: 513998848, Free: 508635256, Diff: 0
#21437, Total: 513998848, Free: 505953496, Diff: 2681760
#48905, Total: 513998848, Free: 503271728, Diff: 2681768
#73394, Total: 513998848, Free: 500589960, Diff: 2681768
#103841, Total: 513998848, Free: 497908192, Diff: 2681768
...

Avis comme l'a signalé libérer de la mémoire n'a pas changé jusqu'à ce que le 21,437 th objet est instancié? Les chiffres suggèrent freeMemory pour la JVM, je suis en utilisant (Java7 Win 64 bits), la précision est d'un peu plus de 2,5 MO (bien que si vous exécutez le test, vous verrez ce nombre varie).

-- Edit --

Ce code est le même que ci-dessus, mais les tirages plus de détails sur l'utilisation de la mémoire. J'espère que c'est un peu mieux comment la JVM de l'utilisation de la mémoire se comporte. Sans cesse, nous allouer de nouveaux objets dans une boucle. Lors de chaque itération, si le totalMemory ou freeMemory est le même que la dernière itération, nous n'avons pas d'imprimer quoi que ce soit. Mais si l'un a changé, nous avons un rapport actuel de l'utilisation de la mémoire. Le ∆ valeurs représentent la différence entre l'utilisation actuelle et le mémoire précédent rapport.

public static void main(String[] args) {
    Runtime rt = Runtime.getRuntime();
    long prevTotal = 0;
    long prevFree = rt.freeMemory();

    for (int i = 0; i < 2_000_000; i++) {
        long total = rt.totalMemory();
        long free = rt.freeMemory();
        if (total != prevTotal || free != prevFree) {
            long used = total - free;
            long prevUsed = (prevTotal - prevFree);
            System.out.println(
                "#" + i +
                ", Total: " + total +
                ", Used: " + used +
                ", ∆Used: " + (used - prevUsed) +
                ", Free: " + free +
                ", ∆Free: " + (free - prevFree));
            prevTotal = total;
            prevFree = free;
        }
        map.put(i, new NewObject());
    }
}

Sur mon portable, je vois la sortie suivante. Notez vos résultats seront différents selon le système d'exploitation, le matériel, la machine JVM, mise en œuvre, etc.:

#0, Total: 83427328, Used: 1741048, ∆Used: 83427328, Free: 81686280, ∆Free: 0
#3228, Total: 83427328, Used: 1741080, ∆Used: 32, Free: 81686248, ∆Free: -32
#3229, Total: 83427328, Used: 2176280, ∆Used: 435200, Free: 81251048, ∆Free: -435200
#7777, Total: 83427328, Used: 2176312, ∆Used: 32, Free: 81251016, ∆Free: -32
#7778, Total: 83427328, Used: 2611536, ∆Used: 435224, Free: 80815792, ∆Free: -435224
...
#415056, Total: 83427328, Used: 41517072, ∆Used: 407920, Free: 41910256, ∆Free: -407920
#419680, Total: 145358848, Used: 39477560, ∆Used: -2039512, Free: 105881288, ∆Free: 63971032
#419681, Total: 145358848, Used: 40283832, ∆Used: 806272, Free: 105075016, ∆Free: -806272
...

Il y a quelques observations à partir de ces données:

1. Utilisation de la mémoire a tendance à augmenter, comme prévu. La mémoire comprend des objets vivants et les déchets.
2. Mais la mémoire utilisée diminue lors d'un GC, parce que les ordures, a été éliminée. Par exemple, cela s'est passé à #419680.
3. La quantité de mémoire libre réduit en morceaux, non-octet par octet. Les morceaux varient en taille. Parfois, les morceaux sont vraiment minuscules, à l'instar de 32 octets, mais en général ils sont plus grands, à l'instar de 400 ou 800. Donc il semble que la taille de segment varie un peu juste. Mais par rapport à l'ensemble de la taille du segment, la variation semble minuscule. Par exemple, au n ° 419681 la taille de bloc est de seulement 0,6% du total de la taille de segment de mémoire.
4. Libérer de la mémoire a tendance à diminuer, comme prévu, jusqu'à ce qu'un GC coups de pied dans et nettoie les déchets. Lorsque cela se produit, libérer de la mémoire augmente assez considérablement, en fonction de la quantité de rebut des déchets.
5. Ce test génère beaucoup de déchets. Comme la table de hachage augmente en taille, il rehashes de son contenu, ce qui génère beaucoup de déchets.