Confusing output from infinite recursion within try-catch

Question

Consider the following code.

public class Action {
private static int i=1;
public static void main(String[] args) {
    try{
        System.out.println(i);
        i++;
        main(args);
    }catch (StackOverflowError e){
        System.out.println(i);
        i++;
        main(args);
    }
 }

}

I am getting i value up to 4338 correctly. After catching the StackOverflowError output getting wired as follows.

4336
4337
4338 // up to this point out put can understand 
433943394339 // 4339 repeating thrice  
434043404340
4341
434243424342
434343434343
4344
4345
434643464346
434743474347
4348
434943494349
435043504350

Consider Live demo here. It is working correctly up to i=4330. Actually how this happen?

FYI:

I did following code to realize what is happening here.

public class Action {

    private static int i = 1;
    private static BufferedWriter bw;

    static {
        try {
            bw = new BufferedWriter(new FileWriter("D:\\sample.txt"));
        } catch (IOException e) {
           e.printStackTrace();
        }
    }

    public static void main(String[] args) throws IOException {
        bw.append(String.valueOf(i)+" ");
        try {
            i++;
            main(args);
        } catch (StackOverflowError e) {
            bw.append(String.valueOf(i)+" ");
            i++;
            main(args);
        }
    }

}

Now previous issue not there. now value of i up to 16824744 correct and and runs further. I am hopping this may runs up to value of i=2,147,483,647(max value of int) without an issue.

There is some issue with println(). There are similar answers bellow too. But why?

What will be the actual reason?

Have a look at this already answered question: http://stackoverflow.com/questions/17828584/why-does-this-method-print-4# — morgano, Aug 19 '13 at 10:18
@morgano I am not asking about that. take a look at this, This is different. yes it is relevant — Ruchira Gayan Ranaweera, Aug 19 '13 at 10:22
No, really, read the question and the answers of that question, I'm not "flagging" your question as duplicated, but it has a lot to do with this behavior of println — morgano, Aug 19 '13 at 10:42
This could have been solved by using basic debugging techniques... — l4mpi, Aug 19 '13 at 11:12
@MartijnCourteaux Theoretically no, but practically yes it should stop. — Ruchira Gayan Ranaweera, Aug 19 '13 at 11:15
Theoretically, this code actually does stop. It takes a crazy amount of time to do so (on the order of `2**max_stack_size`), but it does. — user2357112, Aug 19 '13 at 21:43
I think downvoters consider this as low quality question, they might know the answer. So please if you are a that kind of downvoter leave a answer too, while downvoting. And also there are some good answers down there and please upvote them to help future users.Thanks — Ruchira Gayan Ranaweera, Aug 20 '13 at 07:05

axtavt · Answer 1 · 2013-08-19T13:48:05.117

Note the absence of newline characters in 433943394339. It indicates that something wrong happens inside System.out.println().

The essential point here is that System.out.println() requires some stack space to work, so that StackOverflowError is thrown from System.out.println().

Here is your code with marked points:

public static void main(String[] args) {
    try{
        System.out.println(i); // (1)
        i++;
        main(args); // (2)
    }catch (StackOverflowError e){
        System.out.println(i); // (3)
        i++;
        main(args); // (4)
    }
}

Let's imagine what happens at level N of recursion when i = 4338:

Statement (1) at level N prints 4338. Output 4338\n
i is incremented to 4339
Control flow enters level N + 1 at (2)
Statement (1) at level N + 1 tries to print 4339, but System.out.println() throws a StackOverflowError before it prints a newline. Output 4339
StackOverflowError is caught at level N + 1, statement (3) tries to print 4339 and fails for the same reason again. Output 4339
Exception is caught at level N. At this point there is more stack space available, therefore statement (3) tries to print 4339 and succeeds (newline is printed correctly). Output 4339\n
i is incremented and control flow enters level N + 1 again at (4)

After this point the situation repeats with 4340.

I'm not sure why some numbers are printed correclty between sequences without newlines, perhaps its related to internal work of System.out.println() and buffers it uses.

The ones that print with newlines do so because the recursion does not keep bouncing between 1 frame of stack room left and 0 frames of stack room left. The function is actually tree-recursive. Every function call does eventually return, and when you get `n` frames returning instead of recursing in a row, the next `n` recursive calls have enough stack space not to overflow in `System.out.println`. — user2357112, Aug 19 '13 at 21:40

score 17 · Answer 2 · answered Aug 19 '13 at 10:51

17

What I suspect being happening is this:

Print i
Print newline
Increase i
Enter main
Print i
Print newline
Increase i
Enter main
Print i
StackOverflow got thrown (instead of print newline)
Return to main, now in the catch
Print i
StackOverflow got thrown again (instead of print newline)
Return to main, in another catch body.
Print i
Print newline (now doesn't fail anymore, because we are two levels higher)
Enter main, and go back to 1.

answered Aug 19 '13 at 10:51

Martijn Courteaux

67,591
47
198
287

3

Change the "Catch" print to `"e"+i` and you get semi-repeating groups of `4370e4370e4370` which would say that the second two prints of each number are in the `Catch` - http://ideone.com/BnHqjO – WernerCD Aug 19 '13 at 13:07
Yes, exactly what I expected. This test shows that I'm correct :) Thanks for supporting my thoughts with this example. – Martijn Courteaux Aug 19 '13 at 13:13

score 4 · Answer 3 · edited Jun 20 '20 at 09:12

According to my test:

When Exception is thrown by try Block, i has same value when it comes in catch block (as its not incremented due to exception)

and then inside catch block same exception is thrown and which is again caught by catch block !

I tried Following Code

try {
            System.out.println("Try " + i);
            i++;
            main(args);
        } catch (StackOverflowError e) {
            System.out.println("\nBefore");
            System.out.println("Catch " + i);
            i++;
            System.out.println("After");
            main(args);
            
        }

Output :

Try 28343
Try 28344
Before
Before
Before
Before
Catch 28344
After
Try 28345
Try 28346
Try 28347
Try 28348
Before
Before
Before
Before
Catch 28348
After
Try 28349

when try block throws exception it is caught by catch block but when it goes to System.out.println("Catch " + i); again Exception is thrown 4 times (in my eclipse) Without printing System.out.println("Catch " + i);

As in above output, i have tested it by printing "Before" Text which is printed four times before it prints System.out.println("Catch " + i);

score 3 · Answer 4 · answered Aug 19 '13 at 10:50

If the execution of println (or one of the methods called by it) causes a stack overflow, you will print the same i value from the catch clause of the enclosing main incarnation.

The exact behavior is rather unpredictable as it depends on the stack space still available.

score 1 · Answer 5 · answered Aug 19 '13 at 10:54

As the other answers already explain it has to do with System.out.println requiring extra space on the stack and thus throwing itself a StackOverflowError.

Try this code here to see some different behaviour which shows that at some point there is exceptions being thrown all over the place so that i++ cannot occur anymore.

public class Action {
  private static int i = 1;

  private static StringBuffer buffer = new StringBuffer();

  public static void main(String[] args) {
    try {
      print();
      main(args);
    }
    catch (StackOverflowError e) {
      print();
      main(args);
    }
  }

  private static void print() {
    buffer.append(i).append("\n");
    i++;
    if (i % 1000 == 0) {
      System.out.println("more: " + buffer);
      buffer = new StringBuffer();
    }
  }
}

The important lession to learn is: Never catch Errors as they really indicate that there is something serious wrong with your JVM which cannot be handled normally.

score 1 · Answer 6 · answered Aug 19 '13 at 11:08

The bottom line is that StackOverflowError is an error, not an exception. You are handling an error, not an exception.So the program has already crashed when it enters the catch block.Regarding the strange behaviour of the program, below is the explanation on basis of java buffers from this official doc:

For example, an autoflush PrintWriter object flushes the buffer on every invocation of println or format

The System.out.println() internally calls the PrintStream which is buffered. You don't loose any data from the buffer, it gets all written to the output( terminal in your case) after it fills up, or when you explicitly call flush on it.

Coming back to this scenario, it depends on the internal dynamics of how much the stack is filled up and how many print statements were able to get executed from the catch in main() and those number of characters were written to the buffer. Here after the first try is executed, i.e. in the event of first occurence of the stack overflow, the first System.out.println() fails to print the new line so it flushed the buffer with remaining characters.

score 0 · Answer 7 · answered Sep 09 '13 at 19:10

axtavt Answer is very complete but I'd like to add this:

As you may know the stack is used to store the memory of variables, based on that you cannot create new variables when you reach the limit, it is true that System.out.println will need some stack resources

787     public void More ...println(Object x) {
788         String s = String.valueOf(x);
789         synchronized (this) {
790             print(s);
791             newLine();
792         }
793     }

Then after calling the print, the error does not allow you to even call the newLine, it breaks again right on the print. Based on that you can make sure that's the case by changing your code like this:

public class Action {
    static int i = 1;

    public static void main(String[] args) {
        try {
            System.out.print(i + "\n");
            i++;
            main(args);
        } catch (StackOverflowError e) {
            System.out.print(i + " SO " + "\n");
            i++;
            main(args);
        }
    }
}

Now you will not ask the stack to handle the new lines, you will use the constant "\n" and you may add some debugging to the exception printing line and your output will not have multiple values in the same line:

And it will keep broken until get some resources to allocate new data and pass to the next i value.

Confusing output from infinite recursion within try-catch

7 Answers7

Linked

Related