Understanding How a Single Java Statement Is Executed: From CPU Architecture to JVM Memory Model

Based on the Von Neumann architecture, a modern CPU contains a control unit, arithmetic‑logic unit and internal SRAM, while the main memory (DRAM) holds program instructions that are fetched by the instruction pointer (IP) and decoded by the instruction decoder.

When a Java program is run, the source code is compiled into Java bytecode (e.g., the System.out.println("Hello world") method) which the JVM loads via its class loader. The bytecode is then interpreted or JIT‑compiled into native machine instructions, as shown in the following snippets:

0x00:  b2 00 02   getstatic   java.lang.System.out
0x03:  12 03      ldc         "Hello World!"
0x05:  b6 00 04   invokevirtual java.io.PrintStream.println
0x08:  b1         return

0x00: 55                push   rbp
0x01: 48 89 e5          mov    rbp,rsp
0x04: 48 83 ec 10       sub    rsp,0x10
0x08: 48 8d 3d 3b 00 00 00  lea    rdi,[rip+0x3b]   ; "Hello World!
"
... (subsequent assembly omitted for brevity)

The JVM then creates a stack frame for each method, stores local variables and operand stacks in the thread‑local Java stack, and uses the method area to hold class metadata. Objects have a header containing a mark word and a class pointer; on a 64‑bit JVM with compressed oops the header occupies 12 bytes, and fields are reordered for 8‑byte alignment to avoid cache line splits.

Linux provides each process with its own virtual address space. Physical memory is accessed through paging: a linear address is translated via a page table to a possibly non‑contiguous physical page. Memory‑mapped I/O (e.g., MappedByteBuffer) maps a file directly into a process’s address space, reducing copies between kernel and user buffers.

private void init(final String fileName, final int fileSize) throws IOException {
    this.fileName = fileName;
    this.fileSize = fileSize;
    this.file = new File(fileName);
    this.fileFromOffset = Long.parseLong(this.file.getName());
    ensureDirOK(this.file.getParent());
    try {
        this.fileChannel = new RandomAccessFile(this.file, "rw").getChannel();
        this.mappedByteBuffer = this.fileChannel.map(MapMode.READ_WRITE, 0, fileSize);
        TOTAL_MAPPED_VIRTUAL_MEMORY.addAndGet(fileSize);
        TOTAL_MAPPED_FILES.incrementAndGet();
        ok = true;
    } catch (FileNotFoundException e) {
        log.error("create file channel " + this.fileName + " Failed.", e);
        throw e;
    } catch (IOException e) {
        log.error("map file " + this.fileName + " Failed.", e);
        throw e;
    } finally {
        if (!ok && this.fileChannel != null) {
            this.fileChannel.close();
        }
    }
}

Thread creation in the JVM maps one‑to‑one to Linux kernel threads (NPTL). Threads transition through states such as RUNNABLE, BLOCKED, TIMED_WAITING, and PARKED. Synchronization primitives (e.g., synchronized, volatile, locks) are implemented using monitorenter/monitorexit bytecodes, which ultimately rely on pthread mutexes, but the JVM adds adaptive spinning, lightweight locks, and biased locking to avoid costly kernel syscalls.

public final void wait(long timeout, int nanos) throws InterruptedException {
    if (timeout < 0) throw new IllegalArgumentException("timeout value is negative");
    if (nanos < 0 || nanos > 999999) throw new IllegalArgumentException("nanosecond timeout value out of range");
    if (nanos > 0) timeout++;
    wait(timeout);
}

Java timers (e.g., Timer, ScheduledExecutorService) rely on LockSupport.park or Object.wait to block a thread until the next deadline, using the operating system’s programmable interval timer (PIT) or the CPU’s timestamp counter (TSC) for time measurement. The JVM prefers System.nanoTime() for high‑resolution timing, while System.currentTimeMillis() provides millisecond granularity.

Overall, the execution of a single Java line involves multiple layers of abstraction—from hardware fetch‑decode‑execute cycles, through JVM bytecode interpretation/JIT, to high‑level Java constructs such as memory mapping, object layout, thread scheduling, synchronization, and timer services—each layer contributing to performance characteristics that developers can tune using the concepts described above.