============================================
1: modelo de memoria
============================================
Área compartida de subprocesos: montón (montón) y área de método (área de método)
Subproceso privado: contador de programa, pila de máquina virtual Java, pila de método local.
Heap (montón): la ubicación de almacenamiento de nuevos objetos (el almacenamiento excesivo provocará un desbordamiento de la memoria)
Área de método: almacenar atributos estáticos y constantes (el almacenamiento excesivo provocará un desbordamiento de la memoria)
Contador de programa: puede entenderse como registrar qué línea o instrucción ejecuta el hilo actual. De modo que cuando el hilo vuelve a cambiar, la ejecución puede continuar desde la instrucción actual.
Máquina virtual Java: almacena marcos de pila. Se puede entender que cada vez que se llama a un método, se coloca un marco de pila en la máquina virtual. Si se presiona demasiado en la pila, la pila se desbordará (es decir, el nivel de llamada del método es demasiado profundo).
Pila de métodos nativos: similar a la máquina virtual, pero esta pila se usa para almacenar el marco de pila del método nativo.
============================================
2: división del módulo de memoria
============================================
[ 1: Algoritmo de recuperación ---- Algoritmo de recopilación generacional ]
[ Algoritmo de análisis de accesibilidad ] Algoritmo para marcar si los objetos deben recuperarse
Las referencias a objetos se refieren entre sí utilizando la cadena de referencia como ruta. Si la cadena de referencias a un objeto no está conectada a ninguno de los nodos raíz (GC Roots), muestra que este objeto es inútil, que necesita ser reciclado. Las denominadas referencias de nodo raíz son atributos estáticos, atributos constantes y referencias de marcos de pila. También hay referencias a variables (no digas variables miembro) a las que hacen referencia los métodos nativos. Si no hay referencia a estos cuatro, significa que el objeto es inútil.
El ciclo de vida del objeto se divide en: la generación joven y la generación anterior
------- Cenozoico : Adopte el algoritmo de replicación. (Algoritmo para una tasa de supervivencia de objetos baja)
-------------------- Algoritmo de replicación: Divida la memoria en dos, dividida en dos áreas del mismo tamaño. Solo se usa un área a la vez. Cuando esta área esté casi agotada, todos los objetos supervivientes (algoritmo de análisis de accesibilidad) en esta área se copiarán en otra área, y luego esta mitad del área se limpiará. Cada vez, se recupera toda la zona media.
Desventajas : solo se puede usar la mitad del área de memoria cada vez, y la tasa de uso del espacio de memoria es demasiado baja
Ventajas : alta eficiencia, solo se recupera la mitad del área cada vez. No es necesario considerar el problema de la fragmentación de la memoria, ya que se reorganizará después de la copia y el resto interno
El espacio de almacenamiento está dispuesto de forma completa y continua .
------- Vejez : use un algoritmo de marcación clara o un algoritmo de clasificación de marcas (algoritmo utilizado para una alta tasa de supervivencia de objetos)
-------------------- Algoritmo Mark-clear: Marque los objetos que se reciclarán a través del algoritmo de análisis de accesibilidad, y luego los objetos marcados serán reciclados por el subproceso GC.
Desventaja 1> problema de eficiencia, la marca y la eficiencia no están claras
Desventaja 2> Problema de espacio, se generará una gran cantidad de fragmentos de memoria discontinuos después de borrar. Si posteriormente se va a asignar espacio de memoria a un objeto grande, cuando estos fragmentos de memoria no sean suficientes para tener suficiente espacio, el GC se reclamará nuevamente.
-------------------- Algoritmo de clasificación de marcado: marque los objetos que se reciclarán mediante el algoritmo de análisis de accesibilidad y, a continuación, el hilo de GC reciclará los objetos marcados. Es una versión mejorada del "Algoritmo de eliminación de marcadores". No limpie los objetos reciclables directamente, sino que mueva los objetos supervivientes a un lado, de modo que todos los objetos supervivientes se clasifiquen continuamente en el espacio de la memoria. Luego, limpie directamente los objetos inútiles fuera del límite.
Ventaja 1> resuelve el problema de la fragmentación de la memoria
--------------------- [ Algoritmo Mark-Clear ] Imagen de muestra
--------------------- [ Algoritmo de arreglo de marcado ] Imagen de ejemplo
[ 2: Mecanismo de recuperación del recolector de basura ]
El recolector de basura escanea el objeto que necesita ser reciclado, y nunca se ha llamado al finalize () de este objeto, llamará al finalize () del objeto. Si el objeto finalize () se vuelve a conectar al nodo raíz (por ejemplo: asignando el objeto a una variable estática), el objeto no se reciclará en este momento. Pero si ya se ha llamado al método finalize () del objeto, no se volverá a llamar a finalize () y el objeto se reciclará directamente.
[ 3: Estrategia de reciclaje y asignación de memoria ]
【1: Partición】
La asignación de memoria de los objetos recién nacidos se divide en: Edén > Superviviente > La prioridad del área de ancianos disminuye secuencialmente
Nueva área: Eden y Survivor (algoritmo de copia y recuperación)
Área más antigua: área más antigua (algoritmo de marcado, clasificación y reciclaje)
Nota: No todos los objetos se almacenarán primero en el área nueva. Por ejemplo, si un objeto es particularmente grande, ingresará directamente al área anterior .
Por lo tanto, evitar la creación de objetos grandes hará que el recolector de basura recolecte la basura con anticipación para proporcionar suficiente espacio continuo para colocar objetos grandes.
(La máquina virtual Java puede establecer los límites de objetos grandes mediante parámetros). Más que ponerlo directamente en la zona de ancianos.
[ 2: El movimiento del objeto en el área de memoria ]
<Regla 1> El contador de edad, cada vez que el recolector de basura lo escanea, la edad es +1. Eden se barre una vez y se moverá al área de Superviviente si sobrevive, y si el área de Superviviente se barre 15 veces, se moverá al área anterior. Por supuesto, los parámetros de estos límites se pueden controlar.
<Regla 2> La regla de evaluación de la edad no es única. Si la suma de la memoria ocupada por todos los objetos de la misma edad en el área de Superviviente es mayor que la mitad del espacio de Superviviente, los objetos de más de esta edad se moverán al área de ancianos.
<Regla 3>
1> El objeto solo existirá en el área de Edén y el área Desde de Survivor al principio, y el "Hasta" de Survivor está vacío.
2> Inmediatamente después de GC, todos los objetos supervivientes en el área del Edén se copiarán en "Para", y en el área "Desde", los objetos supervivientes decidirán adónde ir según su edad. Los objetos cuya edad alcance el umbral de edad se moverán a la generación anterior y los objetos que no hayan alcanzado el umbral se copiarán en el área "Para".
3> Minor GC repetirá este proceso hasta que se llene el área "Hasta", y una vez que se llene el área "Hasta", todos los objetos se moverán a la generación anterior.
============================================
2: carga de clases
============================================
La carga de clases se divide en cinco pasos principales:
【1: Cargar】
1: Obtenga este tipo de flujo binario (respectivamente de: zip, red (subprograma), generación en tiempo de ejecución (proxy dinámico))
2: convierta este flujo en un método para ejecutar la estructura de datos
3: Genere el objeto Clase de esta clase como la interfaz de acceso a datos de esta clase en el área de métodos
【2: Conectar】
Segmentación: verificación, preparación, análisis
Verificación : verifique si la codificación se ajusta a UTF-8, si se admite el tipo constante, etc.
Preparación : asignar memoria, inicializar variables
Resolución : la máquina virtual reemplaza las referencias de símbolos de grupo constantes con referencias directas
【3: Inicialización】
El último paso de la carga de clases
【4: Utilice】
Usar es usar propiedades de objeto
【5: Desinstalar】
Desinstalar, puede entenderse como el proceso de referencia se mata
[ La relación entre clase y cargador de clases ]
Comparar si dos clases son iguales o no, solo tiene sentido si las dos clases están cargadas por el mismo cargador de clases. De lo contrario, incluso si las dos clases se originan en el mismo archivo de clase y se cargan en la misma máquina virtual, siempre que el cargador que las carga sea diferente, las dos clases no deben ser iguales.
Java determina si una clase es igual (método equals (), método isAssignableFrom (), método isInstance () devuelve el resultado)
Desde la perspectiva de la máquina virtual Java, solo hay dos tipos de cargadores:
1: iniciar el cargador de clases
2: Cargadores de otras clases
El mecanismo de carga de clases recomendado por los diseñadores de Java a los desarrolladores es: el modelo de delegación padre es como se muestra en la siguiente figura:
La figura anterior muestra el modelo de delegación principal, excepto por el cargador de clases de inicio en la parte superior, otros cargadores tienen sus propios cargadores de clases principales. La relación padre-hijo aquí generalmente no es una relación integrada, sino que toma el código del cargador principal mediante una relación compuesta.
[ Proceso de trabajo del modelo de delegación principal ]
Si un cargador de clases recibe una solicitud de carga, primero enviará la solicitud a la clase principal para completarla. Este es el caso de cada nivel del cargador, por lo que todas las solicitudes eventualmente se pasarán al cargador de clases de inicio superior, solo Cuando el cargador de clases principal informa que no puede completar la tarea de carga, el cargador de clases secundario intentará cargarlo por sí mismo.
【Beneficios】
Este mecanismo de carga tiene una relación jerárquica de prioridad. Al intentar cargar una clase, eventualmente se pasará al cargador de clases de inicio superior, lo que garantiza la singularidad de la clase en el programa. Por ejemplo: por ejemplo, para cargar java.lang.String, almacenado en rt.jar, eventualmente se delegará en el cargador de clases de inicio superior para completar la tarea de carga, por lo que la clase String está en cada entorno de cargador de clases en el programa Ambos son de la misma clase. Por el contrario, si no hay un modelo de delegación parental, cada cargador de clases carga una clase por separado, tome java.lang.String como ejemplo, y cada cargador de clases carga la clase String, entonces habrá múltiples clases String diferentes en el programa. Será muy confuso y no se puede garantizar el comportamiento más básico del programa java.