Lorsque les méthodes vivre? Pile ou dans le Tas?

Je sais que les variables locales et les paramètres des méthodes vivre dans la pile, mais je ne parviens pas à comprendre d'où vient réellement méthodes vivent dans le cas de Java?

Si je déclare tout objet Thread comme:

Thread t=new Thread();
t.start();

Donc, cela signifie que j'ai créé une vocation de méthodes en dehors de la méthode principale. Ça veut dire quoi? Signifie-t-il l'appel de la séquence distincte de méthodes au cours de la Pile de la mémoire? Suis-je le droit?

La manière dont tu énonces cela me rend mal à l'aise. La "Méthode" de "Vie" dans le code de l'espace. Il n'est pas sur la pile ou le tas. Un objet est créé sur le tas qui a un pointeur pour chacun de ses méthodes. Que l'objet réside dans le tas, mais les méthodes de points sont dans le code.

OriginalL'auteur | 2009-07-30

  1. 8

    Chaque thread est attribué sa propre pile.

    Cet article a une bonne introduction à la mémoire de séparation au sein d'un processus Java.

    À l'intérieur de la machine virtuelle Java, chaque
    thread est attribué Java pile, qui
    contient des données aucun autre thread ne peut
    l'accès, y compris les variables locales,
    paramètres et valeurs de retour de chaque
    méthode le thread a été invoquée. L'
    les données sur la pile est limitée à
    les types primitifs et les références de l'objet.
    Dans la JVM, il n'est pas possible de
    placer l'image d'un objet réel sur
    la pile. Tous les objets résider sur le
    tas.

    J'ai vu beaucoup de scénarios où les clients ont mis en œuvre très filetée serveurs sur la base que chaque thread ne fait que très peu, et ils ont des problèmes avec la mémoire. C'est parce que chaque thread est alloué sa propre pile, et c'est (évidemment). Je pense la valeur par défaut est 512 ko par thread, mais je n'en ai pas trouvé un terme source.

    OriginalL'auteur Brian Agnew

  2. 8

    Si je me souviens bien, le code de la méthode elle-même vivra dans la partie du code de la mémoire, alors que les variables déclarées à l'interne vont vivre dans la pile, et les objets seront créés sur le tas. En Java, les variables les pointeurs et les primitives de vivre sur la pile, tandis que tous les objets créés en direct dans le tas.

    Pour une (mauvaise) représentation ASCII:

    -------
|STACK|
-------
|FREE |
-------
|HEAP |
-------
|CODE |
-------

    Où la PILE représente la pile, LIBRE représente libérer de la mémoire, de TAS représente le tas, et le CODE représente le code de l'espace.

    C'est ce que ma mémoire me dit - certains des détails peut-être tort.

    Comme Brian Agnew a fait remarquer, chaque processus a sa propre pile, alors qu'ils partagent le tas.

    OriginalL'auteur aperkins

  3. 6

    La pile est composé d'invocations de méthode. Ce que java pousse sur la pile est une invocation de méthode d'enregistrement, qui encapsule toutes les variables (les deux paramètres et localement instancié variables) pour cette méthode. Lorsque vous démarrez une application Java, la méthode main (ce qui inclut automatiquement le paramètre args) est la seule chose sur la pile:

    main(args)

    Lorsque que vous créez l'objet Foo et appeler foo.méthode(), la pile ressemble maintenant à:

    method()
main(args)

    Que les méthodes appelés, ils sont poussés sur la pile, et qu'ils reviennent, ils sont supprimés ou "sauté" à partir de la pile. Comme les variables sont déclarées et utilisées de la pile, ce qui correspond à la méthode actuelle (en haut de la pile), se développe pour inclure la taille de la variable.

    Pour ton exemple avec les threads, chaque thread a son propre pile, qui existe indépendamment de chaque autre pile du thread.

    OriginalL'auteur Peter

  4. 1

    La pile contient toutes les variables locales et de tous les actifs des appels de méthode.
    Le tas de tenir tout le reste.

    Comme pour votre sous-question: c'est une nouvelle pile est créé avec sa propre mémoire dédiée.
    Bien que votre nouveau thread va partager le total de la mémoire (mémoire) alloués par la jvm

    Je suis assez sûr que la pile contient tous les primitive variables et pointeurs (bien vraiment références) à des objets réels.

    OriginalL'auteur KingInk

  5. 1

    Le segment est divisé en plusieurs générations.

    Le bytecode, et son corrosponding JIT compilé en code machine vies dits de la génération permanente, avec l'internement des Chaînes et d'autres données de la classe.

    Même si elle est appelée la "permanente" de la génération, il peut toujours être nettoyée. Certaines bibliothèques, des cadres et de la JVM langues générer du bytecode au moment de l'exécution, de sorte que la génération permanente parfois besoin de nettoyer. Tout comme les autres générations du tas, mais (en général on espère) moins fréquemment.

    OriginalL'auteur Chris Vest

  6. 0

    Le réel bytecode et/ou JIT avais code vivraient dans l'espace mémoire du processus. Il y aurait vraisemblablement que d'une seule copie dans le processus de la mémoire, comme tous les threads d'un processus donné de partager cette mémoire. Toutes les variables partagé par ces fils seront accessibles par les méthodes ordinaires. Les Variables locales à la threads (même méthode, les variables locales utilisées dans un thread) sera créée au sein du thread de la mémoire.

    OriginalL'auteur Harper Shelby