How to Fix the “Could not create the Java Virtual Machine” Error

Last updated: August 26, 2024

Written by: Sachin Kumar

Reviewed by: David Martinez

JVM Flags

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

Java programs run on a JVM (Java Virtual Machine), allowing them to run almost everywhere, from application servers to mobile phones. If Java is installed properly, we can run applications without problems. However, sometimes we still encounter errors like “Could not create the Java Virtual Machine“.

In this tutorial, we’ll look at the “Could not create the Java Virtual Machine” error. First, we’ll see how to reproduce it. Next, we’ll understand the leading cause of the error, and later we’ll see how to fix it.

2. Understanding the Error

The “Could Not Create the Java Virtual Machine” error occurs when Java cannot create a virtual machine (JVM) to execute a program or application.

This is a very generic error message. The JVM fails at its creation, but the actual cause might be something else, and the error message doesn’t specify why it cannot be created.

How we’ll see this error depends on the running Java-based application that generated it. Java applications such as Eclipse, IntelliJ, and others may only display the main error message.

Running from the terminal, however, produces a main message and further information:

Error occurred during initialization of VM
Could not reserve enough space for object heap
Unrecognized option: <options> etc.

Let’s reproduce the error. First, let’s create a simple HelloWorld class:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

For our example, let’s run HelloWorld with Java 8 with the option -XX:MaxPermSize=3072m. This would run successfully.

However, in Java 17 the -XX:MaxPermSize option was removed and became an invalid option. So, when we run the same class in Java 17 with this option, it fails with “Error: Could not create the Java Virtual Machine“.

Along with the main error, the system returns a specific error message “Unrecognized VM option ‘MaxPermSize=3072m”:

$ java -XX:MaxPermSize=3072m /HelloWorld.java
Unrecognized VM option 'MaxPermSize=3072m'
Error: Could not create the Java Virtual Machine.
Error: A fatal exception has occurred. Program will exit.

To fix this, we need to remove the invalid option and replace it with a valid alternative option if one exists.

3. Possible Causes

If we see the error “Could not create the Java Virtual Machine“, this means that our Java installation cannot launch the JVM, from which applications run.

The error might occur because of several factors. An incorrect Java installation may cause this error. There are various possibilities. For example, if the Java version installed is incompatible with the application or program being attempted to run, the JVM may fail to create. Also, if the installation directory isn’t added to the system’s PATH environment variable, Java may not be identified, resulting in this error.

Furthermore, having multiple Java versions installed might cause issues, resulting in this error. And finally, if a Java update is halted or corrupted, it may cause an incorrect installation.

In some cases, the JVM may not have enough memory to run the program. By default, Java uses an initial and maximum heap size. So, if our application exceeds the maximum heap size, an error occurs. We can adjust this by adjusting the amount of system memory Java can use.

A corrupted Java file or invalid JVM settings can also prevent the JVM from starting, as we saw in our example.

It’s possible that other software or applications could be conflicting with Java, which would prevent the JVM from coming up and this error would arise.

Another cause could be that our system lacks suitable admin access.

4. Possible Solutions

There is not a single fix for all scenarios. Depending on the case we may consider different troubleshooting approaches. But, let’s see some of the basic points we need to verify.

4.1. Verify the Java Installation

First, we must ensure Java is correctly installed by running java -version at the command prompt:

% java -version
java 17.0.12 2024-07-16 LTS
Java(TM) SE Runtime Environment (build 17.0.12+8-LTS-286)
Java HotSpot(TM) 64-Bit Server VM (build 17.0.12+8-LTS-286, mixed mode, sharing)

In addition, we should make sure that the Java installation directory is listed in the system’s PATH environment variable.

4.2. Check the Memory Options

Our next step would be to look at the application memory tuning parameter. Until Java 8 we’ve PermGen memory space that has many flags like -XX:PermSize, XX:MaxPermSize, for tuning the application memory.

From Java 8 onwards, the Metaspace memory space replaces the older PermGen memory space. Many new Metaspace flags are available, including -XX:MetaspaceSize, -XX:MinMetaspaceFreeRatio, and -XX:MaxMetaspaceFreeRatio.

These flags are available to improve application memory tuning. As a result of this improvement, JVM has a reduced chance of getting the OutOfMemory error.

4.3. Check Permissions

Also, sometimes we’ll get errors if there is any problem with access/permission:

java.io.FileNotFoundException: /path/to/file (Permission denied)
java.security.AccessControlException: access denied (“java.io.FilePermission” “/path/to/file” “read”)
java.lang.SecurityException: Unable to create temporary file. Etc.

To resolve these issues, we need to run Java as an administrator or modify the file/directory permissions. When using Windows, we right-click on the terminal or IDE icon and select “Run as administrator“. For Linux and Mac, we use sudo -i or su to open a terminal as the root user.

4.4. Cleanup

Sometimes other Java applications in the system may conflict with ours. We can try identifying them, and then disable or uninstall any Java-related software we’ve installed recently.

Finally, if everything fails, we can try reinstalling Java from scratch.

5. Conclusion

In this article, we looked at Java’s “Could not create the Java Virtual Machine” error. We discussed how to reproduce the error and found out the cause of the exception. Lastly, we looked at a few solutions to resolve the error.

The “Could not create the Java Virtual Machine” error can be resolved by identifying and addressing the underlying cause. By following the troubleshooting steps, we should be able to fix the error in most of the cases and get our Java program running smoothly.