contente
- Ponto de conhecimento
- Código Java escrito, como funciona
- Como se torna um processo JVM após a execução
- Como o processo JVM executa o código que escrevemos?
- Resumir
Ponto de conhecimento
Hoje vou compartilhar com vocês um ponto de conhecimento, ou seja , como é executado o código Java que costumamos escrever e como ele se torna um processo JVM depois de executado? Então, como o processo JVM executa o código que escrevemos ? Esses problemas devem ser desconhecidos para muitos irmãos que escrevem Java há muito tempo.Hoje falaremos sobre esses problemas.
Código Java escrito, como funciona?
Em primeiro lugar, geralmente desenvolvemos um sistema Java. Na verdade, para ser franco, escrevemos muito código Java em nosso Intellij IDEA local. Esses códigos Java são, na verdade, arquivos com o sufixo .java. Os códigos Java que escrevemos são all Os arquivos armazenados nesses arquivos com o sufixo .java não são essencialmente diferentes de escrever um documento com o sufixo .doc em word , conforme mostrado na figura a seguir.
Em seguida, suponha que você tenha escrito algum código, e agora você quer executar o código, você deve fazer uma coisa primeiro, que é compilar . Se você compilar, isso significa que o código Java que você escreveu, nosso computador pode' t entendê-lo, e o código escrito deve ser compilado em uma linguagem de máquina que o computador possa entender, que é bytecode, então neste momento temos que fazer a compilação primeiro. Claro, se você costuma usar o Intellij IDEA, na verdade, ele compila automaticamente o código para você, e o arquivo de bytecode compilado tem um sufixo .class, conforme mostrado abaixo.
Em seguida, o ponto mais importante é que, se você quiser executar o código você mesmo, poderá emitir o comando java para o arquivo .class bytecode na linha de comando. Se estiver usando o Intellij IDEA, clique no botão executar código, pessoal Primeiro, ele compilará o código automaticamente para você e, em seguida, usará diretamente o comando java para executar o arquivo de bytecode .class , conforme mostrado abaixo.
Como ele se torna um processo JVM depois de executado?
Neste momento , uma vez que o comando java é emitido, um processo JVM será iniciado diretamente . Portanto, o processo JVM é assim. Todos devem prestar atenção que a operação de qualquer sistema de classe Java é inseparável do processo JVM. Quando você usa o comando java para executar você Quando o código for escrito, um processo JVM será iniciado e a próxima coisa deverá ser entregue ao processo JVM, conforme mostrado na figura a seguir.
Em seguida, o processo JVM deve fazer uma coisa, ou seja, carregar a classe , ou seja, deve carregar as classes que escrevemos na memória uma a uma, e depois incluir o carregamento de nossa instrução **.class bytecode **, e então podemos executar o código que escrevemos. Neste momento, a primeira classe a ser carregada é a classe principal que contém o método main . Esta classe será a primeira a ser carregada na memória, e os bytes desta classe serão os primeiros As instruções de código também começam a ser executadas, conforme mostrado na figura a seguir.
Portanto, neste momento, a JVM tem duas coisas que podem ser trazidas, uma é a área de métodos , ou a nova versão do Java também pode ser chamada de área de metadados, ou seja, essa área é para armazenar as classes que carregamos a memória, e o outro é o contador de programa , ou seja, essa coisa armazena a próxima instrução de bytecode que queremos executar.Algumas pessoas podem dizer, o que é essa instrução de bytecode? Você provavelmente pode pensar que as instruções de bytecode são o código escrito em nosso método, esses códigos serão convertidos em instruções de bytecode e nossa lógica de código será executada através das instruções de bytecode, conforme mostrado abaixo.
给大家一点稍微形象点的例子，大家看下面一个包含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
原创技术文章汇总