É a pilha de lixo coletado em Java?

Question

A pilha de memória com coleta de lixo em Java.

É a pilha de lixo coletado bem?

Como é a memória de pilha recuperado?

Answer 1

A memória na pilha contém o método de parâmetros e variáveis locais (para ser mais preciso:as referências para os objetos e variáveis de si para tipos primitivos).Que vai ser automaticamente removidos, se você deixar o método.Se as variáveis são referências para objectos) os objectos em si são na pilha e manipulados pelo coletor de lixo.

Assim, a pilha não é lixo coletado da mesma maneira como a pilha, mas pilha, é uma forma de memória automática-gestão própria (que antecedeu a coleta de lixo).

Um resposta mais detalhada é dada por Thomas Pornin, olhar para isso, para mais detalhes.

Answer 2

A pilha não é lixo coletado em Java.

A pilha alocada para uma determinada chamada de método é liberada quando o método retorna. Como essa é uma estrutura LIFO muito simples, não há necessidade de coleta de lixo.

Um lugar onde a coleta de pilha e lixo interage é que as referências na pilha são raízes GC (o que significa que elas são as referências radiculares das quais a acessibilidade é decidida).

Answer 3

A pilha poderia ser lixo coletado.No entanto, na maioria das implementações de JVM, ela é tratada como, também, uma "pilha", que, por definição, exclui a coleta de lixo.

O que nós chamamos de pilha é o acúmulo de método de ativação de contextos:para cada chamado método, esta é a estrutura conceitual que contém o método de argumentos, variáveis locais ocultas ponteiro para o contexto para o método de chamada, e um slot para salvar o ponteiro de instrução.O contexto de activação não é acessível, como tal, a partir da linguagem Java em si.Um contexto torna-se inútil quando o método termina (com um return ou por causa de uma exceção gerada).Acontece que, quando um método de Uma chama um método B, é a garantia de que, quando Um recupera o controle, o contexto para a B tornou-se inútil.Isto implica que o tempo de vida do contexto para B é um subintervalo de toda a vida útil do contexto para a A.Portanto, a ativação de contextos (para um determinado segmento) pode ser atribuída com um LIFO ("Last In, First Out") disciplina.Em palavras mais simples, uma pilha:um novo contexto de activação é empurrado para o topo da pilha de contextos, e o contexto no topo será o primeiro a ser descartado.

Na prática, a ativação de contextos (também chamado de quadros de pilha) são concatenados, na ordem de pilha, em uma área específica.Essa área é obtida a partir do sistema operativo quando a thread é iniciada, e o sistema operacional recebe-lo de volta quando a thread termina.O topo da pilha é indicado por um ponteiro específico, muitas vezes contidas em um registro de CPU (isto depende de JVM é a interpretação ou compilação de código).O "ponteiro para o chamador do contexto" é virtual;contexto do chamador é, necessariamente, localizada logo abaixo em ordem de pilha.O GC não intervir:a área para a pilha é criado e recuperada de forma síncrona, o segmento da atividade em si.Esta é também a forma como ele funciona em diversos idiomas, tais como C, que não tem um GC em todos os.

Agora, nada impede que uma JVM implementação de fazer o contrário, por exemplo,a alocação de contextos de ativação na pilha e tê-los recolhidos pelo GC.Isto não é normalmente feito em Máquinas Virtuais de Java desde a alocação de pilha é mais rápido.Mas algumas outras línguas precisam fazer essas coisas, principalmente aquelas que jogar com continuação e ainda usando um GC (e.g. Regime de e o seu call-with-current-continuation função), porque esses jogos de quebra de LIFO regra explicada acima.

Answer 4

A pilha de parte da memória funciona como uma "pilha".Eu sei que parece ruim, mas isso é exatamente como funciona.Os dados são adicionados ao topo, um em cima do outro (pushed onto the stack) e é automaticamente removido do topo (popped off the stack) como o seu programa é executado.Não é coletado pelo coletor de lixo - e isso não precisa ser desde que a memória é recuperado automaticamente uma vez que os dados é exibido na pilha.E quando eu digo recuperado, eu não quero que ele obtém de-allocated - é só que o local na pilha de memória onde a próxima dados serão armazenados é reduzido, já que os dados exibidos.

É claro que não é para dizer que você não necessita preocupar-se sobre a pilha.Se você executar uma função recursiva muitas vezes ele vai, eventualmente, usar todo o espaço de pilha.Mesmo se você chamar várias funções, especialmente se eles têm muitos parâmetros e/ou variáveis locais.

Mas a linha inferior é que a memória da pilha é utilizada e recuperado como funções de entrar e sair do escopo - se automaticamente.Assim, no final do seu programa de execução de toda a pilha de memória deve ser gratuito e, em seguida, liberado para o sistema operacional.

Answer 5

Se você se referir a memória usada na pilha, não é lixo recolhido.
A máquina virtual java usa explícita bytecode instruções para reserva e liberação de memória na pilha, estas instruções são gerados pelo compilador e gerenciar o tempo de vida dos primitivos, como int,boolean,double e objeto-referências na pilha.
Tem havido planos para implementar um chamado de cauda chamada de otimização, que iria remover algumas entradas da pilha, uma vez que é conhecido que eles não são mais usados, mas eu não sei de qualquer jvm, que já apoia isso.
Portanto, não há nenhuma coleta de lixo para a pilha de si, somente o compilador gerado push e pop instruções para gerenciar o uso de memória.

A pilha de si é parte de um segmento.A pilha é alocada quando o objeto thread é criada e lixo coletado após o segmento termina e o objeto thread não é referenciado.

Answer 6

Todos os objetos em Java são alocados na pilha. (Pelo menos no que diz respeito às especificações, a implementação real pode alocá -las na pilha se elas se comportarem transparentemente como se estivessem na pilha.)

Exatamente o que é colecionável é um pouco sutil. Se a única referência a um objeto estiver em um único quadro de pilha e pode ser mostrado que a referência não será usada novamente, o objeto poderá ser coletado. Se o objeto for usado apenas para ler um campo, essa leitura de campo poderá ser otimizada para a frente e o objeto coletado mais cedo do que você poderia esperar.

Isso geralmente não importa, a menos que você esteja usando FinalIers (ou presumivelmente References). Nesse caso, você deve ter cuidado e usar bloqueios/voláteis para fazer cumprir um happens-before relação.

Quando os threads pararem, normalmente a pilha inteira será desalocada.

Answer 7

Tudo localizado na pilha é tratado como raízes globais por um coletor de lixo. Então, sim, você definitivamente pode dizer que a pilha é "lixo coletado".

Answer 8

Ninguém, de dados é empurrado e bateu de pilha, como você tem o interior variáveis em métodos, durante chamadas de método, etc.Você não precisa se preocupar sobre isso.

Answer 9

Não. A pilha não é lixo coletado em Java. Cada thread tem sua própria pilha e contém:

1. Valores específicos do método (que são de curta duração) e
2. Referências aos objetos, criados em heap, e estão sendo referidos pelo método

Esses valores são pressionados como quadros de pilha para a pilha para cada chamada de método. Como a pilha segue o pedido 'Last-in First-Out', no final de cada chamada de método, cada quadro de pilha que contém todos os dados específicos do método e as referências a objetos, se houver, é lançado.

Portanto, os dados na pilha são limpos automaticamente quando o método/programa sair do escopo.