contenu
- Point de connaissance
- Code Java écrit, comment ça marche
- Comment devient-il un processus JVM après l'exécution
- Comment le processus JVM exécute-t-il le code que nous écrivons ?
- Résumer
Point de connaissance
Aujourd'hui, je vais partager avec vous un point de connaissance, c'est-à- dire comment le code Java que nous écrivons habituellement s'exécute - t-il et comment devient-il un processus JVM après son exécution ? Alors, comment le processus JVM exécute-t-il le code que nous avons écrit ? Ces problèmes doivent être inconnus de beaucoup de frères qui ont écrit Java depuis longtemps, aujourd'hui nous allons parler de ces problèmes.
Code Java écrit, comment ça marche ?
Tout d'abord, nous développons généralement un système Java. En fait, pour parler franchement, nous écrivons beaucoup de code Java dans notre Intellij IDEA local. Ces codes Java sont en fait des fichiers avec le suffixe .java. Les codes Java que nous écrivons sont tous Les fichiers stockés dans ces fichiers avec le suffixe .java ne sont essentiellement pas différents de l'écriture d'un document avec le suffixe .doc dans word , comme illustré dans la figure suivante.
Ensuite, supposons que vous ayez écrit du code et que vous vouliez maintenant exécuter le code, vous devez d'abord faire une chose, et c'est compiler . Si vous compilez, cela signifie que le code Java que vous avez écrit, notre ordinateur peut' t le comprendre, et le code écrit doit être compilé dans un langage machine que l'ordinateur peut comprendre, qui est le bytecode, donc à ce stade, nous devons d'abord faire la compilation. Bien sûr, si vous utilisez habituellement Intellij IDEA, En fait, il compile automatiquement le code pour vous et le fichier de bytecode compilé a un suffixe .class, comme indiqué ci-dessous.
Ensuite, le point le plus important est que si vous souhaitez exécuter le code vous-même, vous pouvez émettre la commande java vers le fichier bytecode .class sur la ligne de commande. Si vous utilisez Intellij IDEA, vous cliquez sur le bouton Exécuter le code, les gens Il compilera automatiquement le code pour vous d'abord, puis il utilisera directement la commande java pour exécuter le fichier bytecode .class , comme indiqué ci-dessous.
Comment devient-il un processus JVM après son exécution ?
À ce stade , une fois la commande java émise, un processus JVM sera démarré directement . Par conséquent, le processus JVM est comme ceci. Tout le monde doit faire attention au fait que le fonctionnement de tout système de classe Java est inséparable du processus JVM. Lorsque vous utilisez la commande java pour vous exécuter Lorsque le code est écrit, un processus JVM sera démarré, et la prochaine chose doit être transmise au processus JVM, comme indiqué dans la figure suivante.
Ensuite, le processus JVM doit faire une chose, c'est-à-dire class loading , c'est-à-dire qu'il doit charger les classes que nous avons écrites en mémoire une par une, puis inclure le chargement de notre **.class bytecode Instruction **, puis nous pouvons exécuter le code que nous avons écrit. A ce moment, la première classe à charger est la classe principale contenant la méthode main . Cette classe sera la première à être chargée dans la mémoire, et les octets de cette classe seront les premiers Les instructions de code commencent également à être exécutées, comme le montre la figure suivante.
Par conséquent, à ce moment, la JVM a deux choses qui peuvent être mises en évidence, l'une est la zone de méthode , ou la nouvelle version de Java peut également être appelée la zone de métadonnées, c'est-à-dire que cette zone sert à stocker les classes que nous avons chargées dans la mémoire, et l' autre est le compteur de programme , c'est-à-dire que cette chose stocke la prochaine instruction bytecode que nous voulons exécuter. Certaines personnes peuvent dire, quelle est cette instruction bytecode ? Vous pouvez probablement penser que les instructions bytecode sont le code écrit dans notre méthode, ces codes seront convertis en instructions bytecode, et notre logique de code sera exécutée à travers les instructions bytecode, comme indiqué ci-dessous.
给大家一点稍微形象点的例子，大家看下面一个包含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
原创技术文章汇总