Java真的很慢吗？

Is Java really slow?

提问by Stefano Borini

Java has some degree of reputation for being slow.

Java以缓慢而闻名。

• Is Java really slow?
• If yes, why? Where is (or was) the bottleneck? Is it because of inefficient JVMs? Garbage collection? Pure bytecode libraries instead of JNI-wrapped C code? Many other languages have these features, but they don't have this reputation for slowness.

• Java真的很慢吗？
• 如果是，为什么？瓶颈在哪里（或曾经是）？是因为 JVM 效率低下吗？垃圾收集？纯字节码库而不是 JNI 包装的 C 代码？许多其他语言具有这些功能，但它们没有这种缓慢的声誉。

采纳答案by BobMcGee

Modern Java is one of the fastest languages, even though it is still a memory hog. Java hada reputation for being slow because it used to take a long time for the VM to start up.

现代 Java 是最快的语言之一，尽管它仍然是一个内存猪。Java的了，因为它曾经花费很长的时间VM启动正在缓慢的声誉。

If you still think Java is slow, see the benchmarks gameresults. Tightly optimized code written in a ahead-of-time compiled language (C, Fortran, etc.) can beat it; however, Java can be more than 10x as fast as PHP, Ruby, Python, etc. There are specific areas where it can beat common compiled languages (if they use standard libraries).

如果您仍然认为 Java 很慢，请查看基准测试游戏结果。用提前编译语言（C、Fortran 等）编写的经过严格优化的代码可以击败它；但是，Java 的速度可以是 PHP、Ruby、Python 等的 10 倍以上。在某些特定领域，它可以击败常见的编译语言（如果它们使用标准库）。

There is no excuse for "slow" Java applications now.Developers and legacy code/libraries are to blame, far more than the language. Also, blame anything 'enterprise.'

现在没有理由让 Java 应用程序“慢”了。开发人员和遗留代码/库应该受到指责，而不仅仅是语言。此外，责怪任何“企业”。

In fairness to the "Java is slow" crowd, here are areas where it is still slow (updated for 2013):

公平地说，对于“Java 很慢”的人群，以下是它仍然很慢的地方（2013 年更新）：

• Libraries are often written for "correctness" and readability, not performance.In my opinion, this is the main reason Java still has a bad reputation, especially server-side. This makes the String problems exponentially worse. Some simple mistakes are common: objects are often used in place of primitives, reducing performance and increasing memory use. Many Java libraries (including the standard ones) will create Strings frequently, rather than reusing mutable or simpler formats (char[] or StringBuffer). This is slow and creates tons of garbage to collect later. To fix this, I suggest developers use primitive collections and especially Javalution's libraries, where possible.

• String operations are a bit slow.Java uses immutable, UTF-16-encoded string objects. This means you need more memory, more memory access, and some operations are more complex than with ASCII (C, C++). At the time, it was the rightdecision for portability, but it carries a small performance cost. UTF-8looks like a better choice now.

• Array access is a bit slower compared to C,due to bounds checks. The penalty used to be big, but is now small (Java 7 optimizes away a lot of redundant bounds checks).

• Lack of arbitrary memory access can make some I/O and bit-level processing slow (compression/decompression for example). This is a safety feature of most high-level languages now.

• Java uses a LOT more memory than C,and if your application is memory bound or memory bandwidth bound (caching, etc.) this makes it slower. The flipside is that allocation/deallocation is blazing fast (highly optimized). This is a feature of most high-level languages now, and due to objects and use of GCrather than explicit memory allocation.Plus bad library decisions.

• Streams-based I/O is slowdue to the (IMO, poor choice) to require synchronization on each stream access. NIOfixed this, but it is a pain to use. One can work around this by doing read/write to an array, instead of an element at a time.

• Java doesn't provide the same low-level functionality C does,so you can't use dirty inline assembler tricks to make some operations faster. This provides portability and is a feature of most high-level languages now.

• It is common to see Java applications tied to very old JVM versions.Especially server-side. These old JVMs can be incredibly inefficient, compared to the latest versions.

• 库通常是为了“正确性”和可读性而不是性能而编写的。在我看来，这是 Java 仍然名声不佳的主要原因，尤其是服务器端。这使得字符串问题呈指数级恶化。一些简单的错误很常见：经常使用对象代替原语，从而降低性能并增加内存使用。许多 Java 库（包括标准库）会频繁地创建字符串，而不是重用可变或更简单的格式（char[] 或 StringBuffer）。这很慢，并且会产生大量垃圾以供稍后收集。为了解决这个问题，我建议开发人员尽可能使用原始集合，尤其是 Javalution 的库。

• 字符串操作有点慢。Java 使用不可变的、UTF-16编码的字符串对象。这意味着您需要更多内存、更多内存访问，并且某些操作比使用 ASCII（C、C++）更复杂。在当时，它是便携性的正确决定，但它带来了很小的性能成本。UTF-8现在看起来是更好的选择。

• 由于边界检查，数组访问比 C 慢一点。惩罚曾经很大，但现在很小（Java 7 优化了很多冗余边界检查）。

• 缺乏任意内存访问可能会使一些 I/O 和位级处理变慢（例如压缩/解压缩）。这是现在大多数高级语言的安全特性。

• Java 使用的内存比 C 多很多，如果您的应用程序受内存限制或内存带宽限制（缓存等），这会使其变慢。另一方面是分配/解除分配非常快（高度优化）。这是现在大多数高级语言的一个特性，并且由于对象和使用GC而不是显式内存分配。加上糟糕的图书馆决定。

• 由于（IMO，糟糕的选择）需要对每个流访问进行同步，因此基于流的 I/O 很慢。NIO解决了这个问题，但使用起来很痛苦。可以通过读取/写入数组而不是一次一个元素来解决此问题。

• Java 不提供与 C 相同的低级功能，因此您不能使用脏的内联汇编器技巧来加快某些操作的速度。这提供了可移植性，并且是现在大多数高级语言的一个特性。

• 经常看到 Java 应用程序绑定到非常旧的 JVM 版本。尤其是服务器端。与最新版本相比，这些旧的 JVM 效率低得令人难以置信。

In the end, Java was designed to provide security and portability at the expense of some performance, and for some really demanding operations it shows. Most of its reputation for slowness is no longer deserved.

最后，Java 旨在以牺牲一些性能为代价提供安全性和可移植性，并且它显示了一些非常苛刻的操作。它以缓慢而闻名的大部分不再应得。

---

---

However, there are several places where Java is fasterthan most other languages:

但是，Java 有几个地方比大多数其他语言要快：

• Memory allocation and de-allocation are fast and cheap.I've seen cases where it is 20% FASTER (or more!) to allocate a new, multi-kB array than to reuse a cached one.

• Object instantiation and object-oriented features are blazing fast to use(faster than C++ in some cases), because they're designed in from the beginning. This is partially from good GC rather than explicit allocation (which is more friendly to lots of small object allocations). One can code C that beats this (by rolling custom memory management and doing malloc efficiently), but it is not easy.

• Method calls are basically free and in some cases faster than large-method code.The HotSpotcompiler uses execution information to optimize method calls and has very efficient inlining. By using the additional execution information, it can sometimes outperform ahead-of-time compilers and even (in rare cases) manual inlining. Compare to C/C++ where method calls come with a small performance penalty if compiler decides not to inline.

• Synchronization and multi-threading are easy and efficient.Java was designed to be thread-aware from the beginning, and it shows. Modern computers usually feature multiple cores, and because threading is built into the language, you can very easily take advantage. Basically an extra 100% to 300% speed boost vs. standard, single-threaded C code. Yes, carefully written C threading and libraries can beat this, but that's a lot of extra work for the programmer.

• Strings include length: some operations are faster.This beats using null-delimited strings (common in C). In Java 7, Oracle took out the String.subString() optimization, because people were using it stupidly and getting memory leaks.

• Array copy is highly optimized.In the lastest versions, Java uses hand-tuned assembler for System.arraycopy. The result is that in arraycopy/memcopy-heavy operations, I've seen my code beat the equivalent in C by reasonable margins.

• The JIT compiler is smart about using L1/L2cache. Ahead-of-time compiled programs can't tweak their code in real-time to the specific CPU & system they're running on. JIT provides some very efficient loop transformations this way.

• 内存分配和取消分配既快速又便宜。我见过分配一个新的多 kB 数组比重用缓存数组快 20%（或更多！）的情况。

• 对象实例化和面向对象的特性使用起来非常快（在某些情况下比 C++ 快），因为它们是从一开始就设计好的。这部分来自于良好的 GC 而不是显式分配（这对大量小对象分配更友好）。可以编写 C 来击败这一点（通过滚动自定义内存管理和有效地执行 malloc），但这并不容易。

• 方法调用基本上是免费的，并且在某些情况下比大方法代码更快。该热点编译器使用的执行信息来优化方法调用，具有非常高效的内联。通过使用额外的执行信息，它有时可以胜过提前编译器，甚至（在极少数情况下）手动内联。与 C/C++ 相比，如果编译器决定不内联，方法调用会带来很小的性能损失。

• 同步和多线程既简单又高效。Java 从一开始就被设计为线程感知，并且它显示了。现代计算机通常具有多个内核，并且由于线程内置于语言中，因此您可以非常轻松地利用它。与标准的单线程 C 代码相比，基本上是额外的 100% 到 300% 的速度提升。是的，精心编写的 C 线程和库可以解决这个问题，但这对程序员来说是很多额外的工作。

• 字符串包括长度：某些操作更快。这优于使用空分隔字符串（在 C 中很常见）。在 Java 7 中，Oracle 取消了 String.subString() 优化，因为人们愚蠢地使用它并导致内存泄漏。

• 数组副本高度优化。在最新版本中，Java 对 System.arraycopy 使用手动调整的汇编程序。结果是在 arraycopy/memcopy-heavy 操作中，我看到我的代码以合理的余量击败了 C 中的等价物。

• JIT 编译器在使用L1/L2缓存方面很聪明。提前编译的程序无法实时调整其代码以适应它们正在运行的特定 CPU 和系统。JIT 以这种方式提供了一些非常有效的循环转换。

A couple of other historical facts contributed to the "Java is slow" reputation:

其他一些历史事实促成了“Java 很慢”的声誉：

• Before JIT compilation (Java 1.2/1.3), the language was only interpreted, not compiled, and thus very slow.
• JIT compilation took time to become efficient (major improvements with each version)
• Classloading has become a lot more efficient over the years. It used to be quite inefficient and slow during startup.
• Swingand UI code did not use native graphics hardware very well.
• Swing is just awful.I blame AWT and Swing for why Java never caught on for the desktop.
• Heavy use of synchronization in library classes; unsynchronized versions are now available
• Applets take forever to load, because of transmitting a full JARover the network and loading the VM to boot.
• Synchronization used to carry a heavy performance penalty (this has been optimized with each Java version). Reflection is still costly, though.

• 在 JIT 编译之前（Java 1.2/1.3），该语言只是解释性的，而不是编译性的，因此非常慢。
• JIT 编译需要时间才能变得高效（每个版本都有重大改进）
• 多年来，类加载变得更加高效。它曾经在启动过程中非常低效和缓慢。
• Swing和 UI 代码没有很好地使用原生图形硬件。
• 摇摆简直太可怕了。我责怪 AWT 和 Swing 为什么 Java 从未在桌面上流行。
• 在库类中大量使用同步；现在可以使用非同步版本
• Applet 需要永远加载，因为通过网络传输完整的JAR并加载 VM 以启动。
• 同步用于带来沉重的性能损失（这已针对每个 Java 版本进行了优化）。然而，反射仍然是昂贵的。

回答by Pascal Cuoq

Java is a high-level language and its reputation nowadays is to have performance on par with other, comparable high-level languages.

Java 是一种高级语言，如今它的声誉是与其他可比较的高级语言相媲美的性能。

1. It has dynamic bindingsemantics. Compared to C++ where non-virtual methods are compiled as function calls, even the best Java compiler in the world has to produce code that is less efficient. But it's also a cleaner, more high-level semantic.

2. I do not remember the details, but I heard in the early days of Java that there was a mutex per Java object, to be acquired and released by each method. That tends to make it better adapted to concurrency, although unfortunately just a mutex per object will not protect you from races or deadlocks or any of the bad things that can happen in concurrent programs. That part, if true, is a little naive, but it came from good intentions. Feel free to fill me in on the details if you know more about this aspect.

3. Another way in which Java is a high-level language is by having Garbage-Collection. Garbage-Collection may be slower than mallocand freefor programs that allocate at once all the memory they need and work with that. The problem is, in languages that do not have Garbage-Collection, programmers tend to write onlyprograms that allocate all the memory they need at once and fail if it turns out some arbitrary maximum size constant has been overflown. So the comparison is apples to oranges. When programmers make the effort to write and debug programs with dynamic allocation of chained structures in non-GC languages, they sometimes find that their programs are no longer faster than in a GC language, because mallocand freeare not free! They have overhead too... Plus, not having a GC forces to specify who frees what, and having to specify who frees what in turn sometime forces you to make copies — when several functions are going to need the data and it's not clear which will be using it last — whereas copying wouldn't have been necessary in a GC language.

1. 它具有动态绑定语义。与将非虚拟方法编译为函数调用的 C++ 相比，即使是世界上最好的 Java 编译器也不得不生成效率较低的代码。但它也是一种更清晰、更高级的语义。

2. 我不记得细节了，但我在 Java 早期听说每个 Java 对象都有一个互斥锁，每个方法都可以获取和释放。这往往使它更好地适应并发，尽管不幸的是，每个对象只有一个互斥锁并不能保护您免受竞争或死锁或并发程序中可能发生的任何不良事件的影响。这部分，如果是真的，有点天真，但它来自良好的意图。如果您对这方面有更多了解，请随时向我详细说明。

3. Java 成为高级语言的另一种方式是使用Garbage-Collection。垃圾收集可能会慢malloc而且free对于分配一次他们需要的所有存储器和工作与程序。问题是，在没有垃圾收集的语言中，程序员倾向于只编写一次分配他们需要的所有内存的程序，如果发现某个任意的最大大小常量溢出，则会失败。所以比较是苹果和橙子。当程序员努力用非 GC 语言编写和调试动态分配链式结构的程序时，他们有时会发现他们的程序不再比 GC 语言快，因为malloc和free不是免费的！它们也有开销......另外，没有 GC 强制指定谁释放了什么，而不得不指定谁释放了什么，有时又会迫使您进行复制——当几个函数需要数据并且不清楚哪个将最后使用它——而在 GC 语言中不需要复制。

回答by Dan Dyer

It's out-dated information from the early days (mid-to-late 1990s) of Java. Every major version of Java has introduced significant speed-ups compared to the previous version. With Oracle apparently merging JRockit with Sun's JVM for Java 7, this trend looks set to continue.

这是 Java 早期（1990 年代中后期）的过时信息。与以前的版本相比，Java 的每个主要版本都引入了显着的加速。随着 Oracle 显然将 JRockit 与 Sun 的 Java 7 JVM 合并，这种趋势看起来将继续下去。

Compared to many other popular modern languages (Python, Ruby, PHP), Java is actually significantly faster for most uses. It doesn't quite match C or C++ but for many tasks it's close enough. The real performance concerns ought to be about how much memory it ends up using.

与许多其他流行的现代语言（Python、Ruby、PHP）相比，Java 在大多数情况下实际上要快得多。它与 C 或 C++ 不太匹配，但对于许多任务来说，它已经足够接近了。真正的性能问题应该是它最终使用了多少内存。

回答by nos

Initially Java was not particularly fast, but it is not overly slow either. These days, Java is very fast. From the people I've talked to the impression of Java being slow comes from two things:

最初 Java 并不算特别快，但也不算太慢。这些天，Java 非常快。与我交谈过的人对 Java 缓慢的印象来自两件事：

1. Slow VM startup time. The early Java implementation took a long time to start up and load the require libraries and the application compared to native applications.

2. Slow UI. Early Swingwas slow. It probably did not help that most Windows users found the default Metal L&F ugly either.

1. VM 启动时间慢。与本机应用程序相比，早期的 Java 实现需要很长时间才能启动和加载所需的库和应用程序。

2. 缓慢的用户界面。Early Swing很慢。大多数 Windows 用户发现默认的 Metal L&F 丑陋可能也无济于事。

Given the above points, it's no wonder people got the 'Java is slow' impression.

鉴于以上几点，难怪人们会有“Java 很慢”的印象。

For users or developers used to developing native applications, or even Visual Basicapplications, these two points are the most visible thing in an application, and it is the first impression you will get about an application (unless it's a non-GUI application in which case only the 1. applies.).

对于习惯于开发原生应用程序，甚至Visual Basic应用程序的用户或开发人员来说，这两点是应用程序中最明显的东西，也是您对应用程序的第一印象（除非它是非 GUI 应用程序，其中仅适用于 1. 的情况。）。

You will not convince a user that "it executes code very fast" when the application takes 8 seconds to start vs. his old Visual Basic application that starts immediately - even though code execution and startup time might not be connected at all.

当应用程序需要 8 秒才能启动时，您不会说服用户“它执行代码的速度非常快”，而他的旧 Visual Basic 应用程序则立即启动——即使代码执行和启动时间可能根本没有联系。

Ruining the first impression is a great way to start rumors and myths. And rumors and myths are hard to kill.

破坏第一印象是开始谣言和神话的好方法。谣言和神话是很难杀死的。

In short, Java is not slow. People having the "Java is slow attitude" is based on first impressions of Java more than 10 years ago.

简而言之，Java 并不慢。有“Java 是慢态度”的人是基于 10 多年前对 Java 的第一印象。

回答by Ken Liu

In the mid-nineties when Java hit the mainstream, C++ was the dominant language, and the web was still fairly new. Also, JVMs and GC were relatively new concepts in mainstream development. The early JVMs were kind of slow (compared to C++ running on bare metal) and also suffered from sometimes long garbage collection pauses, which led to a reputation of Java being slow.

在 Java 成为主流的 90 年代中期，C++ 是占主导地位的语言，而 Web 还相当新。此外，JVM 和 GC 是主流开发中相对较新的概念。早期的 JVM 有点慢（与在裸机上运行的 C++ 相比），并且有时还会遭受长时间的垃圾收集暂停，这导致了 Java 缓慢的名声。

回答by caskey

As Pascal says, Java is on par with other high-level languages. However, as someone who worked with the original JVMs on Windows 98, at the time the level of abstraction provided by the Java virtual machine was, shall we say, painful.

正如 Pascal 所说，Java 与其他高级语言不相上下。但是，作为在Windows 98上使用原始 JVM 的人，当时 Java 虚拟机提供的抽象级别是痛苦的。

Basically, it was software emulation with little or no optimization that we take for granted today in the JVM.

基本上，这是我们今天在 JVM 中认为理所当然的几乎没有优化的软件模拟。

回答by Kaleb Brasee

Java WAS slow, back in the day. It has become much faster, due to a few generations of performance enhancements. Last I heard, it is usually within 10% of C# speed -- sometimes faster, sometimes slower.

过去，Java 很慢。由于几代的性能增强，它变得更快了。最后我听说，它通常在 C# 速度的 10% 以内——有时更快，有时更慢。

Java applet startup is still slow because you've got to start a whole JVM, which has to load all it's classes. Somewhat like booting another computer. Once the JVM starts it is quite fast, but the startup is usually what people remember.

Java 小程序启动仍然很慢，因为您必须启动整个 JVM，它必须加载所有类。有点像启动另一台计算机。一旦 JVM 启动，它会很快，但启动通常是人们所记得的。

Also, there are at least a few peoplethat will never believe in the viability of Java.

此外，至少有一些人永远不会相信 Java 的可行性。

回答by Mr. Boy

People normally trot out the "it's interpreted" line. Because once upon a time, it was, and bad press gets handed down by people who dumped Java as 'too slow' and never returned to test newer versions.

人们通常会说出“它被解释过”的说法。因为曾几何时是这样，而那些将 Java 抛弃为“太慢”并且再也没有回来测试新版本的人传播了负面新闻。

Or perhaps "people are idiots" is a better answer.

或者也许“人们是白痴”是更好的答案。

回答by Spike Williams

For most people's experience interacting with it - Java isslow. We've all seen that coffee cup spinning around on our browser before some applet comes up. It takes a while to spin up the JVM and download the applet binaries, and that impacts the user experience in a way that is noticed.

对于大多数人与之交互的经验 - Java很慢。我们都看到过，在某个小程序出现之前，咖啡杯在我们的浏览器上旋转。启动 JVM 并下载小程序二进制文件需要一段时间，这会以一种明显的方式影响用户体验。

It doesn't help that the slow JVM spin-up and applet download time is conspicuously branded with a Java coffee cup, so people associate the wait with Java. When Flashtakes a long time to load, the branding of the "loading" message is specified by the Flash developer, so people don't blame Flash technology as a whole.

缓慢的 JVM 启动和小程序下载时间明显带有 Java 咖啡杯的烙印，这无济于事，因此人们将等待与 Java 联系起来。当Flash需要很长时间加载时，“加载”消息的烙印是由 Flash 开发人员指定的，因此人们不会责怪 Flash 技术整体。

All of this has nothing to do with Java's performance on a server, or in the many other ways that Java gets used outside the browser. But it's what people see, and what non-Java developers remember when they think about Java.

所有这些都与 Java 在服务器上的性能无关，也与 Java 在浏览器之外使用的许多其他方式无关。但这是人们所看到的，以及非 Java 开发人员在考虑 Java 时所记得的。

回答by Dieter

Stefano:

斯蒂法诺：

I have been with Java since the beginning, so from my point of view the fame of being slow was created by non-responsive and slow GUI frontends (AWT, and then Swing) and in Applets probably because of the additional slow startup times of the VM's.

我从一开始就使用 Java，所以从我的角度来看，缓慢的名声是由无响应和缓慢的 GUI 前端（AWT，然后是 Swing）和 Applets 造成的，这可能是因为额外的缓慢启动时间虚拟机。

Java has stipulated and promoted a lot of research in the VM area, and there have been quite some improvements, including the garbage collection (you can tune a lot of things actually; however, often I see systems where only defaults are used) and hotspot optimization (which at the beginning and probably still is more efficient on the server side).

Java在VM领域规定和推动了很多研究，也有不少改进，包括垃圾收集（其实你可以调很多东西，但是我经常看到系统只使用默认值）和热点优化（在开始时并且可能在服务器端仍然更有效）。

Java at the backend and the computational level is not that slow. Coltis one of the best examples:

后端和计算级别的 Java 并没有那么慢。Colt是最好的例子之一：

The latest stable Colt release breaks the 1.9 Gflop/s barrier on JDK ibm-1.4.1, RedHat 9.0, 2x [email protected] GHz.

最新的稳定版 Colt 打破了 JDK ibm-1.4.1、RedHat 9.0、2x [email protected] GHz 上 1.9 Gflop/s 的障碍。

There are many things outside mainstream Java that should be considered, like Realtime Java or special mechanisms to enhance the speed like Javolution, as well as Ahead-Of-Time compilation (like gcj). Also, there are IC's that can execute Java Bytecode directly, like for example the one that is in the current iPhones and iPods ARM Jazelle.

在主流 Java 之外还有很多东西需要考虑，比如 Realtime Java 或者像Javolution这样的特殊机制来提高速度，以及 Ahead-Of-Time 编译（比如 gcj）。此外，还有一些可以直接执行 Java 字节码的 IC，例如当前 iPhone 和 iPod ARM Jazelle中的 IC 。

I think that generally today it's a political decision (like no Java support on the iPhone/iPod), and a decision against Java as a language (because many think it is too verbose).

我认为今天通常这是一个决定（比如 iPhone/iPod 不支持 Java），以及反对 Java 作为一种语言的决定（因为许多人认为它太冗长了）。

However, there are many other languages for the Java VM nowadays (e.g. Python, Ruby, JavaScript, Groovy, Scala etc.) which may be an alternative.

然而，现在有许多其他的 Java VM 语言（例如 Python、Ruby、JavaScript、Groovy、Scala 等），它们可能是一个替代方案。

Personally I continue to enjoy it as a flexible and reliable platform, with excellent tooling and library availability, that allows one to work with everything from the smallest device (e.g. JavaCard) to the largest servers.

就我个人而言，我继续喜欢它作为一个灵活可靠的平台，具有出色的工具和库可用性，允许人们使用从最小的设备（例如 JavaCard）到最大的服务器的所有内容。