contenido
- punto de conocimiento
- Código Java escrito, cómo funciona
- ¿Cómo se convierte en un proceso JVM después de ejecutarse?
- ¿Cómo ejecuta el proceso JVM el código que escribimos?
- Resumir
punto de conocimiento
Hoy compartiré con ustedes un punto de conocimiento, es decir , ¿cómo se ejecuta el código Java que solemos escribir y cómo se convierte en un proceso JVM después de ejecutarse? Entonces, ¿cómo ejecuta el proceso JVM el código que escribimos ? Estos problemas deben ser desconocidos para muchos hermanos que han escrito Java durante mucho tiempo, hoy hablaremos de estos problemas.
Código Java escrito, ¿cómo funciona?
En primer lugar, generalmente desarrollamos un sistema Java. De hecho, para decirlo sin rodeos, escribimos una gran cantidad de código Java en nuestra Intellij IDEA local. Estos códigos Java son en realidad archivos con el sufijo .java. Los códigos Java que escribimos son all Los archivos almacenados en estos archivos con el sufijo .java no son esencialmente diferentes de escribir un documento con el sufijo .doc en Word , como se muestra en la siguiente figura.
A continuación, supongamos que ha escrito un código y ahora desea ejecutar el código, primero debe hacer una cosa, y es compilar . Si compila, significa que el código Java que ha escrito, nuestra computadora puede ' No lo entiendo, y el código escrito debe compilarse en un lenguaje de máquina que la computadora pueda entender, que es el código de bytes, por lo que en este momento tenemos que hacer la compilación primero. Por supuesto, si generalmente usa Intellij IDEA, de hecho, automáticamente compila el código para usted, y el archivo de bytecode compilado tiene un sufijo .class, como se muestra a continuación.
A continuación, el punto más importante es que si desea ejecutar el código usted mismo, puede emitir el comando java al archivo de código de bytes .class en la línea de comando.Si está utilizando Intellij IDEA, haga clic en el botón ejecutar código, gente Primero compilará automáticamente el código para usted y luego usará directamente el comando Java para ejecutar el archivo de código de bytes .class , como se muestra a continuación.
¿Cómo se convierte en un proceso JVM después de ejecutarse?
En este momento , una vez que se emite el comando java, se iniciará directamente un proceso JVM . Por lo tanto, el proceso JVM es así. Todos deben prestar atención a que la operación de cualquier sistema de clase Java es inseparable del proceso JVM. Cuando use el comando java para ejecutarlo Cuando se escribe el código, se iniciará un proceso de JVM, y lo siguiente debe pasarse al proceso de JVM, como se muestra en la siguiente figura.
A continuación, el proceso JVM debe hacer una cosa, es decir, cargar clases , es decir, debe cargar las clases que escribimos en la memoria una por una, y luego incluir la carga de nuestra instrucción de código de bytes ** .class **, y luego podemos ejecutar el código que escribimos. En este momento, la primera clase que se cargará es la clase principal que contiene el método principal . Esta clase será la primera que se cargará en la memoria, y los bytes en esta clase serán los primeros También se empiezan a ejecutar las instrucciones del código, como se muestra en la siguiente figura.
Por lo tanto, en este momento, la JVM tiene dos cosas que se pueden resaltar, una es el área de métodos , o la nueva versión de Java también se puede llamar el área de metadatos, es decir, esta área es para almacenar las clases que cargamos en la memoria, y el otro es el contador del programa , es decir, esta cosa almacena la siguiente instrucción de código de bytes que queremos ejecutar.Algunas personas pueden decir, ¿qué es esta instrucción de código de bytes? Probablemente pueda pensar que las instrucciones de código de bytes son el código escrito en nuestro método, estos códigos se convertirán en instrucciones de código de bytes y nuestra lógica de código se ejecutará a través de las instrucciones de código de bytes, como se muestra a continuación.
给大家一点稍微形象点的例子，大家看下面一个包含main方法的类的代码：
public class Application {
public static void main(String[] args) {
// 一大堆的代码
}
}
复制代码JVM进程又是如何运行我们写的代码的？
那所以当我们的JVM进程启动之后，针对这个Application类，是不是得加载出来扔自己的方法区这个内存区域里？然后接着JVM进程是不是得执行main方法里一行一行的代码？怎么执行代码？代码编译的时候都搞成字节码指令了，这个时候就得通过程序计数器去引用一条一条的字节码指令，然后通过CPU去运行每条指令，就等于是在运行我们的每一行代码了，如下图。
接着呢在字节码指令运行的过程中，可能会发现你的方法里会有一些局部变量，同时还会创建一些对象，局部变量会引用你创建出来的对象，具体代码可能类似于下面这样子，大家参考一下：
public class Application {
public static void main(String[] args) {
User user = new User();
}
}
复制代码这个时候会发生什么事情呢？也很简单，对于那个User user，这是一个方法内的局部变量，这种变量人家代码指令在运行期间，是会扔到一个地方叫做栈内存里去的，这个栈内存就是放你的方法代码运行期间的局部变量的，然后你用new User()创建的对象呢？这种对象是放到堆内存里去的，这个堆内存是专门放对象的，而且栈内存里的变量会指向堆内存里的对象，如下图。
最后一个概念就是线程，JVM进程实际上会默认开启一个main线程来运行main方法里的代码，也就是main方法里的字节码指令，另外你也可以在代码中开启别的线程的并发运行别的代码了，所以其实还应该引入一个线程执行代码的概念，如下图。
总结
到此为止，我们就可以来总结一下咱们写好的Java代码是如何一步一步运行起来的，如何变成一个JVM进程在不断地运行的了，首先我们的Java代码得编译成字节码，其次我们得用java命令启动一个JVM进程，接着JVM进程会加载我们写好的类到方法区里去，同时还会启动一个默认的main线程，通过程序计数器去指向我们的main方法里的一条一条的指令，通过cpu来运行指令。
接着我们方法的代码指令运行期间，对于局部变量都会扔栈内存里去，对于创建的对象就会扔堆内存里去，随着一个方法运行完毕，就会把这个方法的变量从栈内存里清理掉，然后方法运行期间创建的对象在堆内存里就没人引用了，此时过一段时间以后也会被JVM的一个垃圾回收线程给回收掉这些没人用的对象，这就是咱们的JVM运行原理了。
END
扫码 免费获取 600+页石杉老师原创精品文章汇总PDF
原创技术文章汇总