寻找一篇笔记

↑ ↓ 移动 · Esc 关闭查看全部文章
技术

Java JVM 与 Python 字节码:跨平台和性能到底差在哪

从源码、字节码、运行时到 CPU,讲清 JVM、.class、Python bytecode、.pyc、CPython 的对应关系,以及为什么 Java 和 Python 都跨平台,但 Java 通常跑得更快。

作者:黄撑 更新于 2026-10-04
本文目录 13 节 · 展开收起

很多人第一次接触 Java 和 Python 的运行机制时,会把几个概念混在一起:

  • Java 有 JVM,Python 有 .pyc,它们是不是同一种东西?
  • Java 总说“一次编写,到处运行”,Python 明明也能跨 Windows、Linux、macOS,区别在哪?
  • 两边都隔着一层虚拟机或解释器,为什么 Java 通常还是比纯 Python 快很多?

这些问题其实是一条线上的不同位置。只要先把源码、中间代码、运行时、机器码、CPU分层,很多概念会同时变清楚。

从代码到 CPU
源代码→字节码 / 中间表示→运行时 / VM→机器码→CPU

Java 和 Python 都可以套进这条链。真正的区别,不是“有没有中间层”,而是每一层承担了多少工作。

先纠正一个最容易混淆的对应关系

JVM 和 .pyc 不是同一层。

更准确的对应关系是:

层级JavaPython / CPython
源代码.java.py
字节码JVM BytecodePython Bytecode
常见磁盘形式.class.pyc
执行字节码的运行时JVMCPython
最终执行CPU 机器指令CPU 机器指令

所以:

.class  ≈  .pyc
  ↓          ↓
 JVM    ≈  CPython
  ↓          ↓
 CPU        CPU

这里的“≈”只是帮助理解所在层级,并不代表两边设计完全相同。

.pyc 本质上只是 Python 字节码的缓存文件。Python 导入模块时,可以直接复用已经编译好的 bytecode,省掉再次解析和编译源码的时间。

它不是一个运行环境,更不是 Python 版本的 JVM。

Python 也编译,并不是简单地“逐行读源码”

把 Python 叫作“解释型语言”没有错,但如果把它理解成“解释器直接拿着 .py 文本一行行执行”,就过于简化了。

以 CPython 为例,大致过程是:

hello.py
   ↓
解析源码
   ↓
AST
   ↓
Code Object
   ↓
Python Bytecode
   ↓
CPython 执行

例如:

a = 1
b = 2
c = a + b

CPython 会先得到类似这样的字节码概念:

LOAD_CONST 1
STORE_NAME a

LOAD_CONST 2
STORE_NAME b

LOAD_NAME a
LOAD_NAME b
BINARY_OP +
STORE_NAME c

之后由 CPython 的执行器读取这些指令并完成真正的操作。

.pyc 做的事情,就是把这一阶段产生的 bytecode 缓存下来:

.py  → 编译 → bytecode → 执行
.pyc ─────────→ bytecode → 执行

因此 .pyc 主要减少的是启动和 import 时的编译成本,并不会让后面的 Python 代码突然变成原生机器码。

那 Java 和 Python 不是都能跨平台吗?

是的。

今天从开发者体验来看:

同一份 Java 代码   → Windows / Linux / macOS
同一份 Python 代码 → Windows / Linux / macOS

两者都能做到“一套代码,多平台运行”。

Java 特别强调这一点,更多是因为它把字节码跨平台做成了整个语言和运行时体系的核心设计。

Java:把 JVM 当成统一目标平台

Java 常见链路是:

Hello.java
   ↓ javac
Hello.class
   ↓
┌─────────────┬─────────────┬─────────────┐
Windows JVM   Linux JVM     macOS JVM
   ↓             ↓             ↓
 运行           运行           运行

Java 编译器不需要直接面向 Windows x86、Linux x86、macOS ARM 分别生成程序。

它主要面向一个统一目标:

JVM 这台“虚拟计算机”。

JVM 规范定义了自己的字节码、类格式、类型系统、栈、异常、类加载、线程和内存语义。真正针对不同操作系统和 CPU 做适配的是 JVM 实现。

因此,一个 .jar 中的 JVM bytecode 可以作为相对稳定的交付物。

Python:通常是源码跨平台

Python 更常见的方式是:

hello.py
   ↓
┌────────────────┬────────────────┬────────────────┐
Windows CPython  Linux CPython    macOS CPython
   ↓                ↓                ↓
 运行              运行              运行

所以从“代码能不能到处跑”这个问题看,Python 一样跨平台。

区别在于,Python 通常依赖的是源码层面的跨平台,而不是把 .pyc 当作一个长期稳定、标准化的二进制交付格式。

Python bytecode 会随着 CPython 版本变化,.pyc 更接近解释器内部缓存;而 JVM bytecode 本身就是 Java 生态明确设计出来的一层公共运行格式。

Java 的核心抽象.java → .class → JVM

把 JVM 作为标准目标机器,字节码本身就是正式运行格式。

Python 的常见抽象.py → CPython → 执行

跨平台体验同样成立,但通常依赖源码和对应平台上的解释器。

为什么历史上特别强调 Java 的“一次编写,到处运行”

把时间放回 1990 年代,这件事的意义会明显很多。

C / C++ 程序通常直接编译成本地机器码:

C/C++ 源码
   ↓
Windows 编译器
   ↓
Windows 可执行文件

换到另一个平台:

同一份源码
   ↓
Linux 编译器
   ↓
Linux 可执行文件

而且源码中还经常需要出现平台分支:

#ifdef _WIN32
    // Windows
#elif __linux__
    // Linux
#endif

Java 把中间层做成一个明确的标准平台:

Java
  ↓
.class
  ↓
JVM
  ↓
不同操作系统和 CPU

于是“Write Once, Run Anywhere”在当时是非常有冲击力的工程和产品卖点。

今天 Python、JavaScript、.NET、WebAssembly、容器等方案已经让“隔离底层平台差异”变得非常常见,所以我们现在回头看,会觉得 Python 明明也能做到。

既然都夹着一层,为什么 Java 通常比 Python 快?

这里才是 JVM 和 CPython 差异最明显的地方。

最重要的一句话是:

Java 的 JVM 会把热点代码进一步编译成本地机器码;典型 CPython 则主要继续解释 Python bytecode。

Java:热点代码最终会进入 JIT

Java 程序开始运行后,JVM 可以先解释执行,同时观察哪些代码被频繁调用。

.class bytecode
      ↓
     JVM
      ↓
先解释执行并收集运行信息
      ↓
发现热点代码
      ↓
JIT 编译
      ↓
本地机器码
      ↓
CPU 高速执行

例如:

int c = a + b;

当 JVM 明确知道 a、b、c 都是 int,并且这段代码足够热门时,最终执行可以接近底层的一条整数加法机器指令。

JIT 还能继续做:

  • 方法内联
  • 常量传播
  • 循环优化
  • 边界检查消除
  • 逃逸分析
  • 去虚拟化
  • 基于真实运行数据重新优化

它甚至可以先根据“这个调用点几乎总是 Dog 对象”做激进优化;一旦运行情况发生变化,再撤销之前的假设并回退到更通用的执行方式。

这也是 JVM 的复杂之处:它不是单纯的 bytecode 播放器,而是一套持续观察和优化程序的运行系统。

CPython 慢在哪里:CPU 很快,但它在执行“解释 Python 的程序”

来看一个简单的 Python 加法:

c = a + b

Python 运行时不能天然假设:

a 一定是 int
b 一定是 int

因为下面这些都合法:

a = 1
a = 1.5
a = "hello"
a = [1, 2]
a = SomeCustomObject()

因此一个看似简单的 a + b,运行时可能要考虑:

a 是什么类型?
b 是什么类型?
应该执行哪种加法?
对象有没有自定义 __add__?
结果是什么对象?
引用计数如何变化?

再看一个循环:

total = 0

for i in range(10_000_000):
    total += i

人看到的是:

加法 × 1000 万次

CPython 实际承担的工作更接近:

读取 bytecode
   ↓
取得 Python 对象
   ↓
判断和分派操作
   ↓
执行整数对象的加法逻辑
   ↓
处理对象和引用计数
   ↓
保存结果
   ↓
进入下一轮

然后重复 1000 万次。

Java 热点循环类型稳定 → JIT → 机器码大量运行时判断可以被提前消除或优化。
CPython 纯 Python 循环bytecode → 动态分派 → Python 对象操作每一轮都要支付解释器和动态对象模型的成本。

动态类型为什么会增加优化难度

Python 中:

x = 1

更适合把它理解成:

x
↓
指向一个 Python int 对象
↓
类型信息 + 对象元数据 + 引用管理 + 数值

随后:

x = "hello"

也完全合法。

因此运行时必须保留很强的动态能力。

而 Java:

int x = 1;

已经明确给出了一个重要事实:

x 是 int

类型信息越稳定,JIT 就越容易证明:

某些动态检查在这里永远不需要发生。

一旦能证明,就可以把它们删掉,把高层代码压缩成更接近 CPU 的指令。

这并不意味着“动态类型一定慢、静态类型一定快”,但它解释了为什么高度动态的语言需要付出更多运行时优化成本。

Python 为什么调用 NumPy 又能突然很快

这正好能证明:Python 的慢,很多时候是“每一个细小操作都留在 Python 层执行”造成的。

例如:

# 纯 Python 逐项处理
for i in range(len(a)):
    c[i] = a[i] + b[i]

这里会重复支付大量 Python 层的循环、对象和调度成本。

而:

c = a + b

如果 a、b 是 NumPy 数组,Python 只负责发出一次高层命令:

Python
  ↓
“把两个数组加起来”
  ↓
NumPy 底层 C / C++ / SIMD
  ↓
批量处理大量数据
  ↓
返回结果

于是 Python 只支付一次“进入底层实现”的成本,真正的大量计算交给已经编译好的原生代码完成。

同样的思想也大量存在于:

  • NumPy
  • PyTorch
  • TensorFlow
  • OpenCV
  • Pandas 的部分向量化操作

所以“Python 慢”更准确的说法应该是:

大量细粒度逻辑停留在 CPython 层时,解释器和动态对象模型的成本会很明显。

如果 Python 只是控制层,把重计算一次性交给 C、C++、Rust、CUDA 等底层实现,整体程序仍然可以非常快。

Python 也能做 JIT 吗?

能。

PyPy 就是一个很典型的例子。它通过 JIT 优化 Python 程序,在部分纯 Python 计算场景中可以明显提高性能。

这也说明:

Python 并不是因为“语言名字叫 Python”就天然只能慢。

最终性能来自多个因素的组合:

语言语义
  +
类型和对象模型
  +
具体运行时实现
  +
JIT / AOT 优化能力
  +
程序实际写法

我们日常说“Python 比 Java 慢”,通常默认比较的是:

CPython
vs.
现代 JVM

而不是两个语言规范本身直接比赛。

最后用一张图把所有概念放回正确位置

Java

.java 源码
   ↓ javac
.class / JVM Bytecode
   ↓
JVM
   ↓ 解释 + Profiling + JIT
本地机器码
   ↓
CPU


Python / CPython

.py 源码
   ↓ 编译
Python Bytecode
   ↓ 可缓存为 .pyc
CPython
   ↓ 主要解释执行 / 调用底层实现
CPU

到这里可以把三个最容易混淆的问题压缩成三句话:

  1. .class 和 .pyc 大致处在同一层;JVM 和 CPython 大致处在同一层。
  2. Java 和 Python 都能跨平台;Java 的特殊之处,是把标准字节码 + JVM 做成了整个生态的核心运行平台。
  3. Java 通常比纯 Python 快,不是因为它少了一层,而是 JVM 能利用稳定类型和运行时信息,把热点代码持续优化成本地机器码;CPython 则需要长期承担动态对象和解释执行的成本。

理解这一层之后,再看“编译型语言”和“解释型语言”就不会只有一个二分法了。现代语言真正的运行过程,往往是编译、解释、JIT、原生扩展和运行时优化共同组成的一条链。