Compile & Run — javac, bytecode, và vòng đời một chương trình Java

TL;DR: Khi bạn gõ javac Add.java, Java compiler dịch source code sang bytecode lưu trong Add.class. Khi gõ java Add, JVM nạp bytecode đó, xác minh an toàn qua Bytecode Verifier, rồi thực thi qua Interpreter hoặc JIT. Bytecode là tập lệnh stack-based — mọi tính toán đi qua một operand stack vô danh thay vì register có tên. Lệnh javap -c Add cho bạn nhìn thẳng vào các instruction như iload_0, iadd, ireturn. Từ Java 11, java Add.java compile in-memory và chạy luôn — tiện cho script nhỏ.

Bạn đã viết Hello World. Bạn đã gõ javac và java. Nhưng điều gì thực sự xảy ra giữa hai lệnh đó? Bytecode là gì? Tại sao nó lại là "superpower" của Java?

Bài này đi từ analogy đơn giản đến cấu trúc bytecode thực tế — để bạn hiểu chứ không chỉ thuộc lòng.

Vì sao công thức nấu ăn quốc tế là ẩn dụ chuẩn xác cho Bytecode?

Hình dung bạn viết công thức nấu phở bằng tiếng Việt rất ngon, nhưng đầu bếp Pháp, Nhật hay Mỹ không đọc được.

Giải pháp: dịch công thức sang tiếng Anh chuẩn quốc tế một lần duy nhất. Mọi đầu bếp toàn cầu đều hiểu và dùng chính gian bếp của họ (bếp gas, bếp từ) để nấu ra món ăn đồng nhất.

Javac và java đảm nhận những vai trò gì trong vòng đời chương trình?

javac — biên dịch source code sang bytecode

javac Add.java

• Input: Add.java (mã nguồn con người đọc được).
• Output: Add.class (bytecode dành cho JVM).
• Nếu có lỗi cú pháp, javac dừng lại ngay và không sinh file .class.

java — nạp và thực thi bytecode trên JVM

java Add

• Input: Tên class (không kèm đuôi .class).
• Thực thi: JVM tìm Add.class trong classpath, nạp vào bộ nhớ và kích hoạt hàm main.

Vòng đời thực thi của một chương trình Java diễn ra như thế nào?

1. Source code (Add.java): Lập trình viên soạn thảo logic nghiệp vụ.
2. Biên dịch (javac): Tạo file bytecode Add.class.
3. ClassLoader: Nạp các class cần thiết vào bộ nhớ RAM của JVM.
4. Bytecode Verifier: Kiểm định tính hợp lệ của stack và kiểu dữ liệu trước khi chạy.
5. Execution Engine: Thông dịch (Interpreter) hoặc JIT-compile thành mã máy CPU.

Single-file execution từ Java 11 hoạt động ra sao và dùng khi nào?

Từ Java 11 (JEP 330), bạn có thể chạy trực tiếp một file .java độc lập:

java Add.java

JVM sẽ biên dịch file mã nguồn trực tiếp trong RAM và thực thi ngay lập tức mà không ghi file .class ra ổ đĩa. Tính năng này lý tưởng cho script tự động hóa nhỏ hoặc thử nghiệm nhanh một file.

Classpath là gì và JVM tìm kiếm file class như thế nào?

Classpath là danh sách các đường dẫn mà JVM duyệt qua để tìm nạp các file .class. Mặc định classpath trỏ vào thư mục hiện tại (.):

# Specify directory containing bytecode
java -cp build/classes Add

# Include external jar library
java -cp build/classes:libs/commons-lang3.jar com.example.Main

Nếu một class thuộc package com.example.Add, bạn bắt buộc phải gọi bằng tên đầy đủ (fully qualified class name): java -cp build/classes com.example.Add.

Làm thế nào để compile, chạy và giải mã bytecode bằng javap?

Lấy lại chương trình Hello World từ Bài 04 làm quen — lần này ta sẽ nhìn vào bên trong bytecode của nó. Tạo file Add.java:

// Add.java
public class Add {
    public static int cong(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int ketQua = cong(3, 5);
        System.out.println("3 + 5 = " + ketQua);
    }
}

Compile và chạy:

javac Add.java
java Add
# Output: 3 + 5 = 8

Đọc bytecode bằng javap:

javap -c Add

Output (rút gọn — chỉ phần method cong):

public static int cong(int, int);
  Code:
     0: iload_0       // day bien a len stack (int load tu slot 0)
     1: iload_1       // day bien b len stack (int load tu slot 1)
     2: iadd          // lay 2 gia tri tren stack, cong lai, day ket qua len stack
     3: ireturn       // lay gia tri tren stack, tra ve cho caller

6.1 Giải thích từng instruction

6.2 Bytecode là stack-based, không phải register-based

CPU vật lý (x86, ARM) dùng kiến trúc register-based: tính toán thông qua các "ngăn" có tên cố định (EAX, EBX, R0...).

JVM bytecode dùng kiến trúc stack-based: tính toán thông qua một ngăn xếp vô danh. Thay vì "cộng giá trị trong register EAX với EBX", JVM làm:

1. Đẩy giá trị a lên stack
2. Đẩy giá trị b lên stack
3. iadd lấy 2 giá trị trên stack, cộng, đẩy kết quả lên stack

Vì sao stack-based? Đơn giản hơn, dễ verify (Bytecode Verifier kiểm tra stack state tại compile time), và portable hơn — không cần biết CPU đích có bao nhiêu register.

Thử ngẫmbytecode stack-based để dễ verify và portable, nhưng CPU thật lại register-based. Phần "quy đổi" đó xảy ra ở đâu trong chuỗi javac → JVM → CPU, và vì sao Java chấp nhận trả giá thêm một tầng?

Tại sao kiến trúc bytecode lại đóng vai trò quyết định với Java?

7.1 Portable

Bytecode không phụ thuộc vào Windows, macOS hay Linux. JVM trên mỗi OS dịch bytecode thành machine code native của OS đó. Bạn compile một lần, file .class chạy được mọi nơi có JVM.

7.2 Verifiable — an toàn trước khi chạy

Trước khi execute, Bytecode Verifier của JVM kiểm tra:

• Không có type violation (ví dụ: dùng integer như pointer)
• Không có stack underflow / overflow
• Không có illegal type cast

Đây là lý do Java an toàn hơn C/C++: ngay cả khi ai đó tạo bytecode giả mạo, JVM từ chối thực thi trước khi có cơ hội gây hại.

7.3 Optimizable — JIT compile hot code

JVM không chỉ "đọc" bytecode. Nó theo dõi "hot methods" — method được gọi nhiều lần — và JIT-compile thành native machine code của CPU hiện tại. Kết quả: code Java chạy lâu có thể đạt tốc độ gần bằng C++.

Hệ sinh thái các ngôn ngữ chạy trên JVM mang lại sức mạnh gì?

Bytecode không phải đặc quyền của Java. Nhiều ngôn ngữ khác cũng compile về JVM bytecode — và vì thế interop được với nhau:

Vì sao đây là superpower?

Tất cả các ngôn ngữ trên đều dùng được mọi thư viện Java (500,000+ trên Maven Central) mà không cần wrapper hay binding. Một project có thể có code Java + Kotlin + Groovy trong cùng classpath — chúng gọi nhau trực tiếp vì cùng là bytecode.

// Kotlin code calling Java library directly
import java.util.ArrayList  // Java standard library

fun main() {
    val list = ArrayList<String>()  // Java class, dung tu Kotlin
    list.add("Hello from Kotlin")
    println(list[0])
}

Khi project Kotlin được compile, ArrayList.class của Java và code Kotlin đều là bytecode — JVM không phân biệt.

Thử ngẫmteam bạn có 100.000 dòng Java và muốn thử Kotlin. Nhờ cùng bytecode, bạn viết được file Kotlin đầu tiên ngay cạnh code Java mà không sửa gì chứ? Mắt xích nào trong chuỗi build buộc phải đổi?

Tài liệu chuyên sâu nào giúp đào sâu kiến trúc JVM và bytecode?

Bài học này kết nối như thế nào với lộ trình lập trình Java?

• Java là gì — Bài 01: Bài 01 giải thích tại sao Java cần tầng bytecode trung gian (write once, run anywhere) — bài này là phần "nhìn thấy bytecode thật" của lời hứa đó.
• Hello World — Bài 04: Chương trình đầu tiên bạn compile + chạy. Bài này giải thích những gì thực sự xảy ra bên dưới hai lệnh javac/java mà bài 04 chỉ giới thiệu bề mặt.
• Mini-challenge: Lịch tháng — Bài 07: Bài thực hành đầu tiên — bạn áp dụng toàn bộ vòng đời compile-run để xây chương trình thực.
• Từ code bậc cao tới lệnh máy — khoá Máy tính chạy thế nào: bytecode chỉ là trạm trung gian — bài này đi tiếp xuống tầng dưới, xem trình thông dịch/JIT biến bytecode thành lệnh máy thật mà CPU chạy.

Những điểm cốt lõi cần nhớ về compile và bytecode là gì?

• javac Foo.java → Foo.class (bytecode). java Foo → JVM load và chạy. Bytecode là tập lệnh stack-based, portable qua mọi OS, verifiable và optimizable bởi JIT.
• javap -c Foo.class — đọc bytecode instruction (iload, iadd, invokevirtual...); công cụ thiết yếu để hiểu JVM thực thi gì.
• Single-file execution (java Foo.java, Java 11+): compile in-memory, không tạo .class — tiện cho script, không dùng cho project nhiều file.
• Kotlin, Scala, Groovy, Clojure đều compile về bytecode → interop trực tiếp với Java không cần wrapper — lý do JVM ecosystem rộng hơn chỉ Java.

12. Tự kiểm tra

Bài tiếp theo: Mini-challenge: Viết chương trình in lịch tháng