How to deal with java.lang.OutOfMemoryError: Java heap space error?
Ultimately you always have a finite max of heap to use no matter what platform you are running on. In Windows 32 bit this is around 2GB
(not specifically heap but total amount of memory per process). It just happens that Java chooses to make the default smaller (presumably so that the programmer can't create programs that have runaway memory allocation without running into this problem and having to examine exactly what they are doing).
So this given there are several approaches you could take to either determine what amount of memory you need or to reduce the amount of memory you are using. One common mistake with garbage collected languages such as Java or C# is to keep around references to objects that you no longer are using, or allocating many objects when you could reuse them instead. As long as objects have a reference to them they will continue to use heap space as the garbage collector will not delete them.
In this case you can use a Java memory profiler to determine what methods in your program are allocating large number of objects and then determine if there is a way to make sure they are no longer referenced, or to not allocate them in the first place. One option which I have used in the past is "JMP" http://www.khelekore.org/jmp/.
If you determine that you are allocating these objects for a reason and you need to keep around references (depending on what you are doing this might be the case), you will just need to increase the max heap size when you start the program. However, once you do the memory profiling and understand how your objects are getting allocated you should have a better idea about how much memory you need.
In general if you can't guarantee that your program will run in some finite amount of memory (perhaps depending on input size) you will always run into this problem. Only after exhausting all of this will you need to look into caching objects out to disk etc. At this point you should have a very good reason to say "I need Xgb of memory" for something and you can't work around it by improving your algorithms or memory allocation patterns. Generally this will only usually be the case for algorithms operating on large datasets (like a database or some scientific analysis program) and then techniques like caching and memory mapped IO become useful.
Caused by: java.lang.OutOfMemoryError: Java heap space
This error means that your program needs more memory than your JVM allowed it to use!
Therefore you pretty much have two options:
- Increase the default memory your program is allowed to use using the
-Xmx
option (for instance for 1024 MB:-Xmx1024m
) - Modify your program so that it needs less memory, using less big data structures and getting rid of objects that are not any more used at some point in your program
As Peter Lawrey pointed out, using a profiler to see what your program is doing in such situations is generally a good idea.
java.lang.OutOfMemoryError: Java heap space - Stack Trace Meaning
Unfortunately, the stack just represents the call that failed to allocate memory, but that might not be the cause. There might be other parts in your program that is leaking memory, or maybe you are opening a big document or if your application is web-based, too many users are running some process and they're using all the memory. jvisualvm.exe (which is included in your jdk) is an excellent tool to analyze memory.
GraphDB OutOfMemoryError: Java heap space
By default, the value of the -XX:MaxDirectMemorySize
(off heap memory) parameter in the JVM is equal to the -XMx
(on heap memory). For very large repositories the size of the off heap memory may become insufficient so the GraphDB developers made this parameter 128GB or unlimited.
I suspect that your actual issue is actually allocating too much on heap memory, which leaves no space for the off heap in the RAM. When the database tries to allocate off heap RAM you hit this low OS-level error 'Cannot allocate memory'.
You have two options in solving this problem:
- Increase the RAM of the server to 8GB and keep the same configuration - this would allow the 8 GB RAM to be distributed: 2GB (OS) + 3GB (on heap) + 3GB (off heap)
- Decrease the
-Xmx
value to 2GB so the 4GB RAM will be distributed: 1GB (OS) + 2GB (on heap) + 1GB (off heap)
To get a good approximation how much RAM GraphDB needs please check the hardware sizing page:
http://graphdb.ontotext.com/documentation/8.6/free/requirements.html
Related Topics
Why Does Java Allow Arrays of Size 0
How Can "This" of the Outer Class Be Accessed from an Inner Class
Jackson JSON Custom Serialization for Certain Fields
Why Do Constructors in Java Not Have a Return Type
How to Load Files into My Java Application
How to Read Excel Cell Having Date with Apache Poi
Changing Java Platform on Which Netbeans Runs
Why Would One Declare a Java Interface Method as Abstract
How to Use Hibernate @Any-Related Annotations
How to Run All Tests Belonging to a Certain Category in Junit 4
Java 8: Mandatory Checked Exceptions Handling in Lambda Expressions. Why Mandatory, Not Optional
How to Provide Pagination Support to a Jtable in Swing
Rejectedexecutionexception Inside Single Executor Service
How to Give System Property to My Test via Gradle and -D