3.x StackOverflowError on prinln of Disposable returned from Scheduler

[SergejIsbrecht]

Version:
io.reactivex.rxjava3:rxjava:3.0.6

Example

    @Test
    fun stackoverflow() {
        val scheduleDirect = Schedulers.single().scheduleDirect {
            while (true) { }
        }

        println(scheduleDirect)
    }

This fails as-well:

    @Test
    fun stackoverflow() {
        val scheduleDirect = Schedulers.single().scheduleDirect({
            while (true) {
                // break
            }
        }, 1000, TimeUnit.MILLISECONDS)

        println(scheduleDirect)
    }

but not this:

    @Test
    fun stackoverflow() {
        val scheduleDirect = Schedulers.single().scheduleDirect({
            while (true) {
                break
            }
        }, 0, TimeUnit.MILLISECONDS)

        Thread.sleep(1)

        println(scheduleDirect)
    }

StackTrace:

java.lang.StackOverflowError
	at java.base/java.util.concurrent.FutureTask.toString(FutureTask.java:497)
	at java.base/java.lang.String.valueOf(String.java:2951)
	at java.base/java.util.concurrent.atomic.AtomicReference.toString(AtomicReference.java:275)
	at java.base/java.lang.String.valueOf(String.java:2951)
	at java.base/java.lang.StringBuilder.append(StringBuilder.java:168)
	at java.base/java.util.concurrent.FutureTask.toString(FutureTask.java:513)
	at java.base/java.lang.String.valueOf(String.java:2951)
	at java.base/java.util.concurrent.atomic.AtomicReference.toString(AtomicReference.java:275)
	at java.base/java.lang.String.valueOf(String.java:2951)
	at java.base/java.lang.StringBuilder.append(StringBuilder.java:168)
	at java.base/java.util.concurrent.FutureTask.toString(FutureTask.java:513)
	at java.base/java.lang.String.valueOf(String.java:2951)
	at java.base/java.util.concurrent.atomic.AtomicReference.toString(AtomicReference.java:275)

Analysis:
kind of looks like the toString() has a self reference, which triggers a StackOverflowError

Note: when I set some breakpoints and debug slowly the issue will not happen.

[akarnokd]

Which Java version? There is no line FutureTask.java:497 in JDK 8.

[akarnokd]

On newer JDKs, FutureTask.toString prints the wrapped callable. However, that is essentially goes to an AtomicReference<Future<?>> which is then set to the encompassing future.

The fix is to override toString, but it is not possible to test this without using a newer JDK.

[SergejIsbrecht]

java -version
openjdk version "11.0.6" 2020-01-14
OpenJDK Runtime Environment AdoptOpenJDK (build 11.0.6+10)
OpenJDK 64-Bit Server VM AdoptOpenJDK (build 11.0.6+10, mixed mode)

[SergejIsbrecht]

On newer JDKs, FutureTask.toString prints the wrapped callable. However, that is essentially goes to an AtomicReference<Future<?>> which is then set to the encompassing future.

The fix is to override toString, but it is not possible to test this without using a newer JDK.

openjdk version "1.8.0_265"
OpenJDK Runtime Environment (AdoptOpenJDK)(build 1.8.0_265-b01)
OpenJDK 64-Bit Server VM (AdoptOpenJDK)(build 25.265-b01, mixed mode)

Yes, looks like Java8 works as expected. Interesting. I did not though off this.

[SergejIsbrecht]

@akarnokd , do I get this right?

I call:

    public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) {
        ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run));
        try {
            Future<?> f;
            if (delay <= 0L) {
                f = executor.get().submit(task);
            } else {
                f = executor.get().schedule(task, delay, unit);
            }
            task.setFuture(f);
            return task;
        } catch (RejectedExecutionException ex) {
            RxJavaPlugins.onError(ex);
            return EmptyDisposable.INSTANCE;
        }
    }

f = executor.get().submit(task); task as input Parameter `Callable

The submitted task is of type (as follows). Which is why it is possible to pass it into #submit

io.reactivex.rxjava3.internal.schedulers.ScheduledDirectTask 
                    is AtomicReference<Future<?>> 
                    & Disposable 
                    & SchedulerRunnableIntrospection 
                    & Callable<Void>

The #toString method is overloaded by AtomicReference<T> (inheritance)

    public String toString() {
        return String.valueOf(get());
    }

get() (Future<?>) returns the scheduled task by the executor, which is of type ScheduledFutureTask & FutureTask.

#toString is called upon returned ScheduledFutureTask from #get(), which is implemented as follows:

    public String toString() {
        final String status;
        switch (state) {
        ...
        
        default:
            final Callable<?> callable = this.callable;
            status = (callable == null)
                ? "[Not completed]"
                : "[Not completed, task = " + callable + "]";
        }
        return super.toString() + status;
    }

Because the current state of the Future is currently in NEW or COMPLETING, following branch will be taken:

            status = (callable == null)
                ? "[Not completed]"
                : "[Not completed, task = " + callable + "]";

By taking this branch #toString() will be called upon callable (Callable), which is actually a ScheduledDirectTask. It's #toString() method will be called again (AtomicReference#toString), and we are on our way to a StackOverflowError.

Do you think we should override the toString behavior for ScheduledDirectTask#toString?
Currently #toString() in Java8 returns: java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask@530612ba