Jvm determina se o objeto é lixo

Algoritmo JVM para julgar se é lixo
1. Contador de programa (referências repetidas e referências circulares podem ocorrer)
para derivar raízes gc do algoritmo de acessibilidade
2. A análise de acessibilidade é uma maneira de determinar lixo na coleta de lixo JVM. Outro método é a notação de referência, mas a notação de referência não pode resolver o problema da referência circular.

public class Main {
    
    
    public static void main(String[] args) {
    
    
        MyObject object1 = new MyObject();
        MyObject object2 = new MyObject();
 
        object1.object = object2;
        object2.object = object1;
 
        object1 = null;
        object2 = null;
 
        //最后面两句将object1和object2赋值为null,也就是说object1和object2指向的对象已经不可能再被访问,但是由于它们互相引用对方,导致它们的引用计数都不为0,那么垃圾收集器就永远不会回收它们。
    }
}
 
class MyObject{
    
    
    public Object object = null;
}

Na linguagem Java, os objetos que podem ser usados ​​como GC Roots incluem o seguinte:
Insira a descrição da imagem aqui

Objetos referenciados na pilha da máquina virtual (tabela de variáveis ​​locais no frame da pilha). (Pode ser entendido como: refere-se a todos os objetos da tabela de variáveis ​​locais no frame da pilha)
o objeto referenciado pela propriedade estática na área do método (pode ser entendido como: refere-se a todos os objetos da propriedade estática no
área do método ) o objeto referenciado pela constante na área do método (compreensível Para: todos os objetos que se referem às constantes na área do método
) os objetos referenciados pelo (método nativo) na pilha do método local (pode ser entendido como: todos objetos que se referem ao método nativo)

2.finalze

O objeto salva a si mesmo. Quando o objeto muda de alcançável para inacessível, ele primeiro é restaurado. Neste momento, ele pode voltar e chamar o método finalize
. 1. A subclasse deve renovar o método
. 2. O método só pode ser executado uma vez
e atende aos requisitos acima. Duas situações ---> A execução do thread finalizador subjacente O
método finalize () finalmente determina se o objeto está ativo:

即使在可达性分析算法中不可达的对象,也并非是“非死不可”的,这时候它们暂时处于“缓刑”阶段,要真正宣告一个对象死亡,至少要经历再次标记过程。
标记的前提是对象在进行可达性分析后发现没有与GC Roots相连接的引用链。

1) Marque pela primeira vez e faça uma projeção.

  筛选的条件是此对象是否有必要执行finalize()方法。
  当对象没有覆盖finalize方法,或者finzlize方法已经被虚拟机调用过,虚拟机将这两种情况 都视为“没有必要执行”,对象被回收。

2). A segunda marca

如果这个对象被判定为有必要执行finalize()方法,那么这个对象将会被放置在一个名为:F-Queue的队列之中,并在稍后由一条虚拟机自动建立的、低优先级的Finalizer线程去执行。这里所谓的“执行”是指虚拟机会触发这个方法,但并不承诺会等待它运行结束。这样做的原因是,如果一个对象finalize()方法中执行缓慢,或者发生死循环(更极端的情况),将很可能会导致F-Queue队列中的其他对象永久处于等待状态,甚至导致整个内存回收系统崩溃。
Finalize()方法是对象脱逃死亡命运的最后一次机会,稍后GC将对F-Queue中的对象进行第二次小规模标记,如果对象要在finalize()中成功拯救自己----只要重新与引用链上的任何的一个对象建立关联即可,譬如把自己赋值给某个类变量或对象的成员变量,那在第二次标记时它将移除出“即将回收”的集合。如果对象这时候还没逃脱,那基本上它就真的被回收了。

amontoar

Depois de 1.7, 1.7 cancelou a geração permanente e mudou para meta espaço

  • A nova geração do heap
    Eden: para o sobrevivente: do sobrevivente == 8: 1: 1
    Eden-> para o sobrevivente -> do sobrevivente é continuamente coletado lixo no processo, e então copiado para a próxima área, de sobrevivente para sobrevivente é chamado de um ano, O processo continua em loop até atingir os 15 anos, e os objetos que não foram reciclados entrarão na área antiga. Quando a área do Éden se esgotar, a coleta de lixo será acionada, e os restantes irá mover para a área 1 (para o sobrevivente). O
    algoritmo de coleta de lixo de nova geração é minorGc
  • A proporção da
    geração antiga para a nova geração é de 2: 1. O algoritmo de lixo da geração anterior é classificação e remoção de marcas (fullGc)
  • O GC principal é limpar a geração permanente. A geração permanente é cancelada em 1.8
    . A natureza do metaespaço é semelhante à da geração permanente. Ambos são a realização da área de método na especificação JVM. No entanto, a maior diferença entre o metaspace e a geração permanente é que o metaspace não está na máquina virtual, mas usa a memória local. Portanto, por padrão, o tamanho do meta-espaço é limitado apenas pela memória local (as especificações não são claras)
  • Área do método e heap são compartilhados por threads

memoria jvm

O tamanho padrão da memória jvm é 1/64 da memória local, e a tentativa máxima de memória é 1/4 da memória local

https://blog.csdn.net/qq_38905818/article/details/102500173

Acho que você gosta

Origin blog.csdn.net/qq_38893133/article/details/103882132
Recomendado
Clasificación