Side Effects of running the JVM in debug mode

This question is old but came up while I was searching for any performance impact if you just leave -agentlib:jdwp... on but are not actively debugging.

Summary: Starting with debugging options but not connecting shouldn't impact the speed now (Java 7+).

Before java 6 (ish) you used -Xdebug and this had a definite impact, it shut off the JIT!

In java 6 they changed it to -agentlib and made it better. there were some bugs though that did cause a performance penalty. Here is one of the bugs that was filed against openjdk, My guess is that there were similar problems with The oracle/sun version: https://bugs.openjdk.java.net/browse/JDK-6902182

Note however that the stated goal is that simply enabling debugging by opening the port should not cause any performance penalty.

It looks like, at least in openjdk, the bugs were cleaned up by java 7. I didn't see anything about performance impacts after that.

If you research this further and find negative results, take note of the java version the testing was done under--everything I saw was referring to versions before 7.

I'd love to hear if anyone encountered performance problems in a recent VM just leaving the port enabled.

The program definitely does lot more than simply running when in debugging mode, so it is obvious that performance can not be same. However if you read the statement carefully, it says that new release can run fully optimized code even if in debugging mode which was not possible earlier. Thus the new jvm is much more faster than previous one which could only run in interpreted mode which no optimization.

I can't speak for HotSpot, and won't officially for IBM, but I will say there are certainly legal kinds of optimization that aren't possible to undo fully should a decompilation be required in the middle of them, and thus aren't enabled when debug is being asked for in the production JVMs you are likely to use.

Imagine a situation where the optimizer discovers a part of the program is provably not required and by the various language rules (including JSR 133) is legal to remove, the JVM will want to get rid of it. The one wrinkle is debug: removing the code will look odd to the human stepping through it (variables not updating, possibly not stopping on lines when stepping) so the choice is to disable said optimizations in those cases. The same might also be true for opts like stack allocated objects, etc.. so while the JVM says it's "full speed" it's actually closer to "nearly full speed, with some of the funkier opts that can't quite be undone removed".

If you plan to run the app with remote debugging enabled, it can affect security also. Remote debugging leaves a port open on your machine, and by connecting to it, I can do all sorts of fun things with your application.