descripción general
Para obtener más contenido del blog, visite solo me encanta comer fruta del dragón , haga clic para obtener más información.
Cuando la JVM ejecuta el código, utiliza múltiples espacios de memoria, y se utilizan diferentes espacios de memoria para almacenar diferentes datos y luego cooperar con el flujo de código para hacer que el sistema funcione.
Almacenar información de carga de clase
Para dar el ejemplo más simple, por ejemplo, ahora sabemos que la JVM cargará clases en la memoria para la operación posterior, por lo que debe haber un área de memoria en la JVM para almacenar las clases que escribimos.
Esta área se denomina área de método en versiones anteriores a JDK 1.8 , que representa un área en la JVM. Es principalmente para cargar las clases desde el archivo ".class", y habrá algunas cosas como grupos constantes en esta área. Pero después de JDK 1.8, el nombre de esta área se cambió a "Metaspace" , que puede considerarse como "espacio de metadatos". Por supuesto, almacena principalmente varios tipos de información relacionada escrita por nosotros mismos.
public class Client {
public static void main(String[] args) {
//使用支付宝付款
Shopping shop = new Shopping(new Alipay());
shop.payMoney();
}
}
public class Shopping
{
private PayMethod payMethod;
public Shopping(PayMethod payMethod)
{
this.payMethod = payMethod;
}
//付钱,支付用什么方式付钱,客户自己选择
public void payMoney()
{
String name = payMethod.getClass().getName();
System.out.println("我在购物,现在要付钱了");
payMethod.payMoney();
}
}
public class Alipay implements PayMethod
{
@Override
public void payMoney()
{
System.out.println("我在使用支付宝支付");
}
}
 Cuando el código se está ejecutando, necesita ejecutar un método en el código. Al ejecutar el método, hay muchas variables en el
método Las cosas de la clase deben colocarse en un área de memoria determinada.Si se crean algunos objetos en el código, estos objetos también necesitan espacio de memoria para almacenar.
contador de programa
El código Java que escribimos se traducirá a código de bytes, correspondiente a varias instrucciones de código de bytes. Primero, el código Java se compila en instrucciones de código de bytes, y luego las instrucciones de código de bytes deben ejecutarse una por una, para que la ejecución del código pueda realizarse. Efecto. Entonces, cuando la JVM carga la información de clase en la memoria, en realidad usará su propio motor de ejecución de bytecode para ejecutar las instrucciones de código compiladas por el código.
Al ejecutar instrucciones de código de bytes, se necesita un área de memoria especial en la JVM, es decir, el "contador de programa".
Este contador de programa se utiliza para registrar la ubicación de las instrucciones de código de bytes que se están ejecutando actualmente , es decir, para registrar la ejecución actual cuyo código de bytes instrucción.
JVM admite múltiples subprocesos, por lo que, de hecho, el código puede abrir múltiples subprocesos para ejecutar diferentes códigos al mismo tiempo, por lo que habrá múltiples subprocesos para ejecutar diferentes instrucciones de código al mismo tiempo, por lo que cada subproceso tendrá su propio contador de programa. es ejecutado actualmente por el subproceso actual.
Pila de máquina virtual Java
Cuando se ejecuta el código Java, debe haber un subproceso para ejecutar el código en un método determinado, incluso si es el siguiente código, habrá un subproceso principal para ejecutar el código en el método main(), y el principal() El método se ejecutará en el hilo principal. Cuando se instruye el código, el contador de programa correspondiente al hilo principal registrará la posición de la instrucción ejecutada por sí mismo.
public class Client {
public static void main(String[] args) {
//使用支付宝付款
Shopping shop = new Shopping(new Alipay());
shop.payMoney();
}
}
En el método, a menudo definimos algunas variables locales en el método. Por ejemplo, en el método main() anterior, en realidad hay una variable shoplocal " ", que se refiere a un Shoppingobjeto de instancia. No se preocupe por este objeto. primero mire los métodos y las variables locales.
Por lo tanto, la JVM debe tener un área para guardar datos como variables locales en cada método , y esta área es la pila de la máquina virtual Java. Cada subproceso tiene su propia pila de máquina virtual Java. Por ejemplo, el subproceso principal aquí tendrá su propia pila de máquina virtual Java, que se utiliza para almacenar las variables locales de los métodos que ejecuta. Si un subproceso ejecuta un método, se crea un marco de pila correspondiente para la llamada al método.
En el marco de la pila, hay tablas de variables locales, pilas de operandos, enlaces dinámicos, salidas de métodos, etc. de este método. Concéntrese primero en las variables locales.
Por ejemplo, si el subproceso principal ejecuta el método main(), se creará un marco de pila para este método main() y la pila de la máquina virtual Java del subproceso principal se insertará en el marco de pila del subproceso principal. Al mismo tiempo, el " " correspondiente se almacenará en el marco de la pila de las shopvariables locales del método main(). Luego suponga que el subproceso principal continúa ejecutando Shoppingel método en el objeto, como el siguiente, payMoneyse define una variable local en el método " ": " name"
Si payMoneyse ejecuta el método " ", el payMoneymétodo " " también se extraerá de la pila de la máquina virtual Java.
Lo anterior es el rol del componente "Java Virtual Machine Stack" en la JVM**: cuando se llama y ejecuta cualquier método, se creará un marco de pila para el método y luego se insertará en la pila. **Los datos como las variables locales correspondientes a este método se almacenan en el marco de la pila, incluida otra información relacionada con la ejecución de este método, y la pila aparecerá después de que se ejecute el método.
Memoria de montón de Java
Memoria heap de Java, aquí es donde se almacenan los diversos objetos que creamos en el código.
Por ejemplo el siguiente código:
public class Client {
public static void main(String[] args) {
//使用支付宝付款
Shopping shop = new Shopping(new Alipay());
shop.payMoney();
}
}
El new Shopping()código " " anterior es para crear una Shoppinginstancia de objeto de una clase, que contendrá algunos datos, como se muestra en el siguiente código.
public class Shopping {
private PayMethod payMethod;
public Shopping(PayMethod payMethod) {
this.payMethod = payMethod;
}
//付钱,支付用什么方式付钱,客户自己选择
public void payMoney() {
String name = payMethod.getClass().getName();
System.out.println("我在购物,现在要付钱了");
payMethod.payMoney();
}
}
El " Shopping" en esta clase " " payMethodes un dato que pertenece a esta instancia de objeto. Las instancias de objetos como Shoppingeste se almacenan en la memoria del montón de Java.
Los objetos similares se colocarán en el área de memoria del montón de Java Shopping, y luego, debido a que creamos Shoppingel objeto en el método principal, cuando el subproceso ejecuta el código del método principal, estará en la tabla de variables locales del marco de pila correspondiente al método principal, deje que una shopvariable local de tipo de referencia " " almacene Shoppingla dirección del objeto. Es equivalente a que usted puede pensar que el " " en la tabla de variables locales shopapunta al objeto en la memoria del montón de Java Shopping.
Una charla de proceso completo sobre el área de la memoria central
io=1&rotation=0&showTitle=false&size=98630&status=done&style=none&title=&width=651.5)
- Cuando se inicia el proceso de JVM, primero cargará la clase de Cliente en la memoria. Luego hay un subproceso principal, que comienza a ejecutar el método main() en Client.
- El subproceso principal está asociado con un contador de programa, por lo que la línea de instrucción que ejecuta se registrará aquí. Cuando el subproceso principal ejecuta el método main(), empujará un marco de pila del método main().
- Luego encontrará que necesita crear un
Shoppingobjeto de instancia de una clase, yShoppingla clase se cargará en la memoria en este momento. - Luego, se creará y asignará una
Shoppinginstancia de objeto en la memoria del montón de Java, y se introducirá una variable " " en la tabla de variables locales en el marco de la pila del método main()shoppara hacer referencia aShoppingla dirección del objeto en el montón de Java. memoria. - Luego, el subproceso principal comienza a ejecutar
Shoppingel método en el objeto y empujará secuencialmente el marco de pila correspondiente al método que ha ejecutado en su propia pila de máquina virtual Java, y luego eliminará el marco de pila correspondiente al método de la máquina virtual Java. pila de la máquina después de ejecutar el método la pila