J'ai décidé d'essayer quelques expériences pour voir ce que je pouvais découvrir sur la taille des images de pile, et à quelle distance dans la pile le code en cours d'exécution était. Il y a deux questions intéressantes que nous pourrions examiner ici:

1. combien de niveaux profondément dans la pile est le code actuel?
2. combien de niveaux de récursivité la méthode actuelle peut-elle atteindre avant d'atteindre un StackOverflowError?

Profondeur de pile du code en cours d'exécution

Voici le meilleur I pourrait venir avec pour cela:

public static int levelsDeep() {
    try {
        throw new SomeKindOfException();
    } catch (SomeKindOfException e) {
        return e.getStackTrace().length;
    }
}

Cela semble un peu hacky. Il génère et attrape une exception, puis cherche à voir quelle est la longueur de la trace de la pile.

Malheureusement, il semble aussi avoir une limitation fatale, qui est que la longueur maximale de la trace de pile retournée est 1024. Tout ce qui est au-delà est éliminé, donc le maximum que cette méthode peut renvoyer est 1024.

Question:

y a-t-il une meilleure façon de faire cela qui ne l'est pas hacky et n'a pas cette limitation?

Pour ce que ça vaut, je suppose qu'il n'y en a pas: Throwable.getStackTraceDepth() est un appel natif, ce qui suggère (mais ne prouve pas) que cela ne peut pas être fait en Java pur.

Déterminer combien il nous reste de profondeur de récursivité

Le nombre de niveaux que nous pouvons atteindre sera déterminé par (A) la taille du cadre de la pile, et (b) la quantité de pile restante. Ne nous inquiétons pas de la taille du cadre de la pile, et il suffit de voir combien de niveaux nous pouvons atteindre avant de frapper un StackOverflowError.

Voici mon code pour faire ceci:

public static int stackLeft() {
    try {
        return 1+stackLeft();
    } catch (StackOverflowError e) {
        return 0;
    }
}

Il fait son travail admirablement, même s'il est linéaire dans la quantité de pile restante. Mais voici la partie très, très bizarre. Sur Java 7 64 bits (OpenJDK 1.7.0_65), les résultats sont parfaitement cohérents: 9,923, sur ma machine (Ubuntu 14.04 64 bits). Mais Java 8 D'Oracle (1.8.0_25) me donne des résultats non déterministes : j'obtiens une profondeur enregistrée comprise entre environ 18 500 et 20 700.

, Maintenant, pourquoi sur terre serait-il non déterministe? Il est censé y avoir une taille de pile fixe, n'est-ce pas? Et tout le code me semble déterministe.

Je me demandais si c'était quelque chose de bizarre avec le piégeage d'erreur, alors j'ai essayé ceci à la place:

public static long badSum(int n) {
    if (n==0)
        return 0;
    else
        return 1+badSum(n-1);
}

Clairement, cela retournera soit l'entrée qui lui a été donnée, soit le débordement.

Encore une fois, les résultats que j'obtiens sont non déterministes sur Java 8. Si j'appelle badSum(14500), Il me donnera un StackOverflowError environ la moitié du temps, et retournera 14500 l'autre moitié. mais sur Java 7 OpenJDK, c'est cohérent: badSum(9160) se termine bien, et badSum(9161) déborde.

Question:

pourquoi la profondeur de récursivité maximale est-elle non déterministe sur Java 8 D'Oracle? Et pourquoi est-ce déterministe sur OpenJDK 7?