Given:
11. class Snoochy {
12. Boochy booch;
13. public Snoochy() { booch = new Boochy(this); }
14. }
15.
16. class Boochy {
17. Snoochy snooch;
18. public Boochy(Snoochy s) { snooch = s; }
19. }
And the statements:
21. public static void main(String[] args) {
22. Snoochy snoog = new Snoochy();
23. snoog = null;
24. // more code here
25. }
Which statement is true about the objects referenced by snoog,
snooch, and booch immediately after line 23 executes?
A. None of these objects are eligible for garbage collection.
B. Only the object referenced by booch is eligible for garbage
collection.
C. Only the object referenced by snoog is eligible for garbage
collection.
D. Only the object referenced by snooch is eligible for garbage
collection.
E. The objects referenced by snooch and booch are eligible for garbage
collection.
Bom a resposta correta está á “E” mas o objeto referenciado por “snoog” que recebe null na linha 23 tb está referenciado por “snooch” então quando “snoog” recebe null o objeto ainda é referenciado por “snoog” sendo assim esse objeto nao esta elegivel para a coleta, e o objeto referenciado por booch tb não é elegivel para a coleta, a resposta nao seria á alternativa “A” não? Ou estou errado?
Depois da linha 23 booch referencia um objeto Boochy que por sua vez referencia o próprio objeto que é referenciado por snoog na thread principal. Ou seja, snooch dentro de Boochy referencia snoog.
Só que, um objeto é considerado lixo a partir da hora em que nenhuma thread consegue fazer referência a ele.
Esse programa tem somente uma thread (main) e a partir da linha 23, apesar dessas referências, a thread main não pode mais chegar a esses objetos, pq snoog aponta para null.
Como é que vc faria pra acessar o objeto snooch dentro de Boochy a partir da thread main, por exemplo?
[quote=evertonsilvagomesjava]Given:
11. class Snoochy {
12. Boochy booch;
13. public Snoochy() { booch = new Boochy(this); }
14. }
15.
16. class Boochy {
17. Snoochy snooch;
18. public Boochy(Snoochy s) { snooch = s; }
19. }
And the statements:
21. public static void main(String[] args) {
22. Snoochy snoog = new Snoochy();
23. snoog = null;
24. // more code here
25. }
Which statement is true about the objects referenced by snoog,
snooch, and booch immediately after line 23 executes?
A. None of these objects are eligible for garbage collection.
B. Only the object referenced by booch is eligible for garbage
collection.
C. Only the object referenced by snoog is eligible for garbage
collection.
D. Only the object referenced by snooch is eligible for garbage
collection.
E. The objects referenced by snooch and booch are eligible for garbage
collection.
Bom a resposta correta está á “E” mas o objeto referenciado por “snoog” que recebe null na linha 23 tb está referenciado por “snooch” então quando “snoog” recebe null o objeto ainda é referenciado por “snoog” sendo assim esse objeto nao esta elegivel para a coleta, e o objeto referenciado por booch tb não é elegivel para a coleta, a resposta nao seria á alternativa “A” não? Ou estou errado? [/quote]
Você está errado.
Esse é um exemplo daquele negócio de ilha de objetos.
Quando você seta null para snoog você não tem mais meios para acessar booch, sendo assim booch e seus objetos são elegidos para o garbage colector.
Hummm rood e frango acho que entendi, quando snoog recebe null, automaticamente booch que esta dentro do objeto de snoog tb recebe null que por sua vez o objeto referenciado por booch tb recebera null. Isso mesmo né? Obrigado!
Não é isso. Somente snoog recebe null. As outras ainda são referências para objetos reais no heap. Porém nenhuma thread pode acessá-las. Se você fizer o desenho StackxHeap passo a passo fica mais fácil de enxergar.
rood mas quando vc fala que nenhuma Trhead consegue acessa-lo e pq chegou no fim do escopo do main? Pq snoog recebendo null nao tem como mais acessar mesmo o objeto booch…No javaranch esta falando isso como snoog foi setado com null o objeto booch nao pode ser mais acessado caindo na especie de “ilha de isolamento”.
Você perguntou acima se todas as referências recebem null por causa da linha 23. A resposta é não. Mesmo depois da linha 23 executar, booch ainda referencia um objeto válido no heap, e esse booch tem um objeto chamado snooch que tem uma referência válida para um objeto do tipo Snoochy, que por coincidência é o mesmo objeto que snoog referenciava.
Mas eu te pergunto: Como você faria para acessar esses objetos em seu programa, depois de a linha 23 executar?
Os objetos são válidos, ainda existem, e ainda existem referências a eles. Porém, nenhuma thread em execução ( no caso desse programa só existe a thread main) pode “alcançar” esses objetos.
O único meio pelo qual vocÊ conseguiria acessar esses objetos em main seria utilizando a variável snoog. A partir da linha 23 o garbage collector vê que não existe mais nada que você possa fazer para acessar estes objetos, e os trata como lixo. Hora ou outra os mesmos serão coletados. Não porque main acaba ali. Você poderia continuar o programa, chamar mais zilhões de métodos a partir de main. Mas nenhum deles seria capaz de acessar estes objetos.
Nossa agora entendido d mais cara eheh muito obrigado, na realidade o objeto referenciado por booch ainda existe no heap porem e tratado como lixo pois nao tem como mais ser acessado daí vem a tal ilha de isolamento. Obrigado rod.
Isso mesmo. Quando surgirem mais dúvidas como essa, eu sugiro que você faça o desenho Stack X Heap.
Veja anexo o desenho que fiz para esse exercício. O X vermelho mostra o que acontece quando a linha 23 executa. A partir dali os objetos ficam isolados no heap.
Edit: Esqueci de escrever no desenho. O círculo maior é a memória heap.
