Stack overflow error java

How to Fix java.lang.StackOverflowError in Java

Table of Contents

The java.lang.StackOverflowError is a runtime error which points to serious problems that cannot be caught by an application. The java.lang.StackOverflowError indicates that the application stack is exhausted and is usually caused by deep or infinite recursion.

What Causes java.lang.StackOverflowError in Java

The java.lang.StackOverflowError occurs when the application stack continues to grow until it reaches the maximum limit. Some of the most common causes for a java.lang.StackOverflowError are:

1. Deep or infinite recursion — If a method calls itself recursively without a terminating condition.
2. Cyclic relationships between classes — If a class A instantiates an object of class B , which in turn instantiates an object of class A . This can be considered as a form of recursion.
3. Memory intensive applications — Applications that rely on resource heavy objects such as XML documents, GUI or java2D classes.

java.lang.StackOverflowError Example in Java

Here is an example of java.lang.StackOverflowError thrown due to unintended recursion:

In this example, the recursive method print() calls itself over and over again until it reaches the maximum size of the Java thread stack since a terminating condition is not provided for the recursive calls. When the maximum size of the stack is reached, the program exits with a java.lang.StackOverflowError :

How to fix java.lang.StackOverflowError in Java

Inspect the stack trace

Carefully inspecting the error stack trace and looking for the repeating pattern of line numbers enables locating the line of code with the recursive calls. When the line is identified, the code should be examined and fixed by specifying a proper terminating condition. As an example, the error stack trace seen earlier can be inspected:

In the above trace, line number 4 can be seen repeating, which is where the recursive calls are made and causing java.lang.StackOverflowError .

Increase Thread Stack Size (-Xss)

If the code has been updated to implement correct recursion and the program still throws a java.lang.StackOverflowError , the thread stack size can be increased to allow a larger number of invocations. Increasing the stack size can be useful, for example, when the program involves calling a large number of methods or using lots of local variables.

The stack size can be increased by changing the -Xss argument on the JVM, which can be set when starting the application. Here is an example:

This will set the thread’s stack size to 4 mb which should prevent the JVM from throwing a java.lang.StackOverflowError .

Track, Analyze and Manage Errors With Rollbar

Managing errors and exceptions in your code is challenging. It can make deploying production code an unnerving experience. Being able to track, analyze, and manage errors in real-time can help you to proceed with more confidence. Rollbar automates Java error monitoring and triaging, making fixing errors easier than ever. Try it today.

Источник

StackOverflowError в Java

StackOverflowError в Java

1. обзор

StackOverflowError может раздражать разработчиков Java, поскольку это одна из самых распространенных ошибок времени выполнения, с которыми мы можем столкнуться.

В этой статье мы увидим, как может возникать эта ошибка, на различных примерах кода и узнаем, как с ней бороться.

2. Фреймы стека и как происходитStackOverflowError

Давайте начнем с основ. When a method is called, a new stack frame gets created on the call stack. Этот кадр стека содержит параметры вызванного метода, его локальные переменные и адрес возврата метода, т.е. точка, с которой выполнение метода должно продолжаться после возврата вызванного метода.

Создание кадров стека будет продолжаться до тех пор, пока не будет достигнут конец вызовов методов, найденных во вложенных методах.

Во время этого процесса, если JVM обнаруживает ситуацию, когда нет места для создания нового кадра стека, она выдастStackOverflowError.

Наиболее частая причина, по которой JVM может столкнуться с этой ситуацией, —unterminated/infinite recursion — в описании Javadoc дляStackOverflowError упоминается, что ошибка возникает в результате слишком глубокой рекурсии в конкретном фрагменте кода.

Однако рекурсия не является единственной причиной этой ошибки. Это также может произойти в ситуации, когда приложение хранитcalling methods from within methods until the stack is exhausted. Это редкий случай, так как ни один разработчик не будет намеренно следовать плохой практике кодирования Другая редкая причина —having a vast number of local variables inside a method.

StackOverflowError также может быть выброшено, если приложение разработано для использованияcyclic relationships between classes. В этой ситуации конструкторы друг друга вызывают неоднократно, что приводит к возникновению этой ошибки. Это также можно рассматривать как форму рекурсии.

Другой интересный сценарий, который вызывает эту ошибку, — этоclass is being instantiated within the same class as an instance variable of that class. Это приведет к тому, что конструктор одного и того же класса будет вызываться снова и снова (рекурсивно), что в конечном итоге приведет кStackOverflowError.

В следующем разделе мы рассмотрим несколько примеров кода, демонстрирующих эти сценарии.

3. StackOverflowError в действии

В примере, показанном ниже,StackOverflowError будет выброшено из-за непреднамеренной рекурсии, когда разработчик забыл указать условие завершения для рекурсивного поведения:

Здесь ошибка выдается во всех случаях для любого значения, переданного в метод:

Однако в следующем примере указано условие завершения, но оно никогда не выполняется, если значение-1 передается методуcalculateFactorial(), что вызывает незавершенную / бесконечную рекурсию:

Этот набор тестов демонстрирует этот сценарий:

В этом конкретном случае ошибки можно было бы полностью избежать, если бы условие завершения было просто сформулировано как:

Вот тест, который демонстрирует этот сценарий на практике:

Теперь давайте рассмотрим сценарий, в которомStackOverflowError возникает в результате циклических отношений между классами. Давайте рассмотримClassOne иClassTwo, которые создают экземпляры друг друга внутри своих конструкторов, вызывая циклическую связь:

Теперь предположим, что мы пытаемся создать экземплярClassOne, как показано в этом тесте:

В итоге получаетсяStackOverflowError, поскольку конструкторClassOne создает экземплярClassTwo,, а конструкторClassTwo снова создает экземплярClassOne.. И это происходит неоднократно, пока он не переполнится. стек.

Далее мы рассмотрим, что происходит, когда создается экземпляр класса в том же классе, что и переменная экземпляра этого класса.

Как видно в следующем примере,AccountHolder создает экземпляр переменной экземпляраjointAccountHolder:

Когда создается экземпляр классаAccountHolder,, вызываетсяStackOverflowError из-за рекурсивного вызова конструктора, как показано в этом тесте:

4. Работа сStackOverflowError

Лучшее, что можно сделать при обнаруженииStackOverflowError, — это осторожно изучить трассировку стека, чтобы определить повторяющийся шаблон номеров строк. Это позволит нам найти код с проблемной рекурсией.

Давайте рассмотрим несколько трассировок стека, вызванных примерами кода, которые мы видели ранее.

Эта трассировка стека создаетсяInfiniteRecursionWithTerminationConditionManualTest, если мы опускаем объявление исключенияexpected:

Здесь строка № 5 видна повторяющейся. Это где рекурсивный вызов делается. Теперь остается просто изучить код, чтобы убедиться, что рекурсия выполнена правильно.

Вот трассировка стека, которую мы получаем, выполняяCyclicDependancyManualTest (опять же, без исключенияexpected):

Эта трассировка стека показывает номера строк, которые вызывают проблему в двух классах, которые находятся в циклическом отношении. Строка номер 9ClassTwo и строка номер 9ClassOne указывают на место внутри конструктора, где он пытается создать экземпляр другого класса.

Как только код тщательно проверен, и если ни одно из следующего (или любая другая логическая ошибка кода) не является причиной ошибки:

Неправильно реализованная рекурсия (т.е. без условия прекращения)

Циклическая зависимость между классами

Создание класса внутри того же класса, что и переменная экземпляра этого класса

Было бы неплохо попробовать увеличить размер стека. В зависимости от установленной JVM размер стека по умолчанию может варьироваться.

Флаг-Xss можно использовать для увеличения размера стека либо из конфигурации проекта, либо из командной строки.

5. Заключение

В этой статье мы более подробно рассмотрелиStackOverflowError, включая то, как код Java может вызывать это, и как мы можем диагностировать и исправить это.

Исходный код, относящийся к этой статье, можно найтиover on GitHub.

Источник

Diagnosing a java.lang.StackOverflowError

Troubleshooting

Problem

Stack Overflow exceptions can occur when a thread stack continues to grow in size until reaching the maximum limit.

Symptom

A stack overflow can result from:

• A deeply nested application
• An infinite loop within an application
• A problem in just-in-time (JIT) compiled code
• Applications requiring a larger stack size, especially ones relying on XML, GUI, or java2D classes.
• Native method calls

Stack overflow issues are frequently masked by Out of Memory exceptions. By resolving the memory constraints, the stack overflow can be resolved.

Cause

When a stack overflow occurs, the amount of stack space required by the program exceeds what is configured for the stack in the Java™ Virtual Machine (JVM) process, or the native stack size configured by the operating system.
Some applications require stacks that are larger than the default size; for example, a graphics-intensive Java program can require a larger stack, which may require an increase in the stack size to avoid StackOverflow.

Diagnosing The Problem

Look for either Out of Memory messages or java.lang.StackOverflow in the server logs. The process may continue to run after either of these messages are seen.

If a crash did occur, a javacore should have generated on IBM SDK. You will either see the signal as SIGSEGV, SIGILL, SIGABRT, or SIGBUS. Usually the current thread will indicate the following

Resolving The Problem

Explanations and Solutions

Detailed Configuration Options

Infinite Recursion
If an application is performing recursion, the maximum stack size can easily be reached and a Stack Overflow exception is thrown. The thread stack has a limited size and eventually its space will run out as the thread stack grows without bounds.

Some traits of recursion:
— Large thread stacks that appear to repeat
— An infinite loop that continuously spawns off threads
— Very large XML documents loaded into the Document Object Model (DOM)
— JSP or servlets calling itself (usually by executing forward or include to itself)
— Repeated calls in native functions

Increasing the thread stack size allows for larger thread stacks. However if the recursion continues to trigger a stack overflow, the next step is to identify what code is causing the recursion from javacores, thread dumps, or even system core files.

A thread stack that indicates it’s too large to display can be an indicator of stack overflow. This is especially true if the stack appears to repeat (such as recursive method calls).

JIT/HotSpot Compiled Code

The JIT/HotSpot compiler (JIT) is designed to speed up the JVM execution times by compiling method calls. This can speed up execution time, but as more aggressive optimizations are used, this can inadvertently cause recursion, resulting in stack overflow or crash. The documents linked below explain how to debug JIT and HotSpot compiler issues:

• JIT Problem Determination for IBM SDK 5.0 and 6.0 using -Xjit
• Debugging HotSpot failures on the Solaris and HP-UX operating environment

Depleted Native Stack
It is almost guaranteed that a crash will occur if the native stack runs out of space. System cores can be used to identify long and possibly recursively looping native thread stacks.

To resolve, increase the native stack size (usually by adjusting the operating system limit for stack size) to accommodate the recursive native calls; however, identifying the recursive native calls will help determine the root cause of the stack overflow.

Back to top

Adjusting the Stack Sizes (Xss and Xmso) options
If this does not work, you can adjust the stack sizes. Doubling the stack size is suggested as a first step; however, every thread that the JVM creates will consume memory. Be careful to not exhaust your physical and heap memory resources.

For every Java thread, there are two stacks that are utilized. One is for Java code for method calls, and the other is for native C code (on Solaris and HP-UX, only the native stack is utilized). These are adjustable and can be raised to provide more room on the stacks to prevent an overflow.

Maximum Thread Stack Size (-Xss)
This parameter controls the stack size of Java method calls (non-native) to track the state of variables. If you find looping code or large stacks that are all calling Java methods and do not make native calls, try raising the stack size by using the generic JVM argument below:

Where has the format, nn[k|m|g|K|M|G], such as -Xss512K

On Solaris and HP-UX systems which use the HotSpot JVM, there is no distinction between native and thread stack sizes. This is the only configurable value for all stack sizes; however, on HP-UX systems, there is another argument used to control stack size of the main method.

While the -Xss controls the stack size of all threads in native memory, -XX:MainThreadStackSize controls the size of the main thread. The main thread’s native size will be set to whichever value is higher.

Initial Thread Stack Size (-Xiss)
This is only for distributed platforms (AIX, Linux, Windows)

Adjusts the initial thread stack size that the JVM will start with. The default for all distributed platforms is 2KB. In most cases, you will not need to change this option.

Where has the format, nn[k|m|g|K|M|G], such as -Xiss2K

Initial Native Stack Size (-Xmso)
This is only for distributed platforms (AIX, Linux, Windows)

This parameter controls the initial stack size of native (operating system) threads. Java code uses this to process calls made into native libraries, such as JIT or JNI calls. If there is an abundance of calls made on the native stack, adjust the native stack size using this generic JVM argument:

Where has the format, nn[k|m|g|K|M|G], such as -Xmso512K.

NOTE: The maximum stack size for the operating system is controlled by ulimit -s on UNIX and Linux.

Default Values
This is a chart of default sizes for the various stack size arguments. This is subject to change due to upgrades of the SDK.

Источник

Introduction

StackOverFlowError is one of the common JVM error. In this blog post, let’s learn inner mechanics of thread stacks, reasons that can trigger StackOverFlowError and potential solutions to address this error.

To gain a deeper understanding of this exception, let’s review this simple program:

public class SimpleExample {

 public static void main(String args[]) {

  a();
 }

 public static void a() {

  int x = 0;
  b();
 }

 public static void b() {

  Car y = new Car();
  c();
 }

 public static void c() {

  float z = 0 f;
  System.out.println("Hello");
 }
}

This program is very simple with the following execution code:

• main() method invoked first
• main() method invokes a() method. Inside a() method integer variable ‘x’ is initialized to value 0.
• a() method in turn invokes b() method. Inside b() method Car object constructed and assigned to variable ‘y’.
• b() method in turn invokes c() method. Inside c() method float variable ‘z’ is initialized to value 0.

Now let’s review what happens behind the scenes when the above simple program executed. Each thread in the application has its own stack. Each stack has multiple stack frames. Thread adds the methods it’s executing, primitive data types, object pointers, return values to its stack frame in the sequence order in which they got executed.

In step #1: main() method pushed into the application thread’s stack. Step #2: a() method pushed into application thread’s stack. In a() method, primitive data type ‘int’ is defined with value 0 and assigned to variable x. This information also pushed into the same stack frame. Note both data i.e. ‘0’ and variable ‘x’ pushed into thread’s stack frame.

In step #3: b() method pushed into thread’s stack. In b() method, ‘Car’ object created and assigned to variable ‘y’. A crucial point to note here is ‘Car’ object created in the heap and not in the thread’s stack. Only Car object’s reference i.e. y stored in the thread’s stack frame.

In step #4: c() method pushed into thread’s stack. In c() method, primitive data type ‘float’ is defined with value 0f and assigned to variable z. This information is also pushed into the same stack frame. Note both data i.e. ‘0f’ and variable ‘z’ is pushed into thread’s stack frame.

2. StackOverFlowError Cause

As you can see thread’s stack is storing methods it’s executing, primitive data types, variables, object pointers and return values. All of these consume memory. If thread’s stack sizes grow beyond the allocated memory limit then StackOverflowError is thrown. Let’s look at the below buggy program, which will result in StackOverflowError:

public class SOFDemo {

 public static void a() {

  // Buggy line. It will cause method a() to be called infinite number of times.
  a();
 }

 public static void main(String args[]) {

  a();
 }
}

In this program main() method invokes a() method. a() method recursively calls itself. This implementation will cause a() method to be invoked an infinite number of times. In this circumstance, a() method got added to thread’s stack frame an infinite number of times. Thus, after a few thousand iterations thread’s stack size limit might exceeded. Once stack size limit exceeds, it will result in ‘StackOverflowError’:

Exception in thread "main" java.lang.StackOverflowError
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)
	at com.buggyapp.stackoverflow.SOFDemo.a(SOFDemo.java:7)

3. Solutions to StackOverflowError

There are a couple of strategies to address StackOverflowError.

3.1 Fix the Code

Because of a non-terminating recursive call (as shown in the above example), threads stack size can grow to a large size. In that circumstance, you must fix the source code which is causing recursive looping. When ‘StackOverflowError’ is thrown, it will print the stacktrace of the code that it was recursively executing. This code is a good pointer to start debugging and fixing the issue. In the above example it’s ‘a()’  method.

3.2 Increase Thread Stack Size (-Xss)

There might be a legitimate reason where a threads stack size needs an increment. Maybe thread has to execute a large number of methods or lot of local variables/created in the methods thread has been executing. In such circumstance, you can increase the thread’s stack size using the JVM argument: ‘-Xss’. Pass this argument when you start the application. Example:

-Xss2m

This will set the thread’s stack size to 2 Mb. It might bring a question, what is the default thread’s stack size? Default thread stack size varies based on your operating system, java version & vendor.

Summary

In this article, we took a closer look at the StackOverflowError.We got an understanding of the cause of this error along with the options to fix this issue.

The java.lang.stackoverflowerror – StackOverflow Error in Java is thrown to indicate that the application’s stack was exhausted, due to deep recursion.

The StackOverflowError extends the VirtualMachineError class, which indicates that the JVM is broken, or it has run out of resources and cannot operate. Furthermore, the VirtualMachineError extends the Error class, which is used to indicate those serious problems that an application should not catch. A method may not declare such errors in its throw clause, because these errors are abnormal conditions that shall never occur.

Finally, the StackOverflowError exists since the 1.0 version of Java.

You can also check this tutorial in the following video:

1. The Structure of StackOverflowError

Constructors

• StackOverflowError()

Creates an instance of the StackOverflowError class, setting null as its message.

• StackOverflowError(String s)

Creates an instance of the StackOverflowError class, using the specified string as message. The string argument indicates the name of the class that threw the error.

2. The StackOverflowError in Java

When a function call is invoked by a Java application, a stack frame is allocated on the call stack. The stack frame contains the parameters of the invoked method, its local parameters, and the return address of the method. The return address denotes the execution point from which, the program execution shall continue after the invoked method returns. If there is no space for a new stack frame then, the StackOverflowError is thrown by the Java Virtual Machine (JVM).

The most common case that can possibly exhaust a Java application’s stack is recursion. In recursion, a method invokes itself during its execution. Recursion is considered as a powerful general-purpose programming technique, but must be used with caution, in order for the StackOverflowError to be avoided.

An example that throws a StackOverflowError is shown below:

StackOverflowErrorExample.java

In this example, we define a recursive method, called recursivePrint that prints an integer and then, calls itself, with the next successive integer as an argument. The recursion ends once we invoke the method, passing 0 as a parameter. However, in our example, we start printing numbers from 1 and thus, the recursion will never terminate.

A sample execution, using the -Xss1M flag that specifies the size of the thread stack to equal to 1MB, is shown below:

Depending on the JVM’s initial configuration, the results may differ, but eventually the StackOverflowError shall be thrown. This example is a very good example of how recursion can cause problems, if not implemented with caution.

3. More about the java.lang.stackoverflowerror

The following example demonstrates the risk of having cyclic relationships between classes:

StackOverflowErrorToStringExample.java:

In this example, we defined two classes, A and B. The class A contains one instance of the B class, while, the B class contains one instance of the A class. Thus, we have a circular dependency between these two classes. Furthermore, each toString method, invokes the corresponding toString method of the other class, and so on, which results in a StackOverflowError.

A sample execution is shown below:

4. How to deal with the java.lang.stackoverflowerror

• The simplest solution is to carefully inspect the stack trace and detect the repeating pattern of line numbers. These line numbers indicate the code being recursively called. Once you detect these lines, you must carefully inspect your code and understand why the recursion never terminates.
• If you have verified that the recursion is implemented correctly, you can increase the stack’s size, in order to allow a larger number of invocations. Depending on the Java Virtual Machine (JVM) installed, the default thread stack size may equal to either 512KB, or 1MB. You can increase the thread stack size using the -Xss flag. This flag can be specified either via the project’s configuration, or via the command line. The format of the -Xss argument is:
  -Xss<size>[g|G|m|M|k|K]

5. Additional knowledge

• STACKOVERFLOWERROR: CAUSES & SOLUTIONS
• java.lang.ClassNotFoundException – How to solve Class Not Found Exception
• Unreachable Statement Java Error – How to resolve it
• java.lang.NullPointerException Example – How to handle Java Null Pointer Exception (with video)
• Try Catch Java Example
• Java Stack Example (with video)
• Online Java Compiler – What options are there
• What is null in Java

6. Download the Eclipse Project

This was a tutorial about the StackOverflowError in Java.

Last updated on Oct. 12th, 2021

Troubleshooting