Improving onSchedule hook implementation

Hi, We are actively using RxJava in multiple of our projects. In some of #the cases I would like to be able to register multiple ScheduleHandler handlers. For example one for the zipkin/brave and another one for our own project related purposes. I’m proposing some changes to the RxJavaPlugins class that will allow to do that without breaking a current API. I can create a PR but here is a patch for now:

 import java.lang.Thread.UncaughtExceptionHandler;
 import java.util.concurrent.*;
+import java.util.*;
 
 import org.reactivestreams.Subscriber;
 
 import io.reactivex.*;
+import io.reactivex.Observable;
+import io.reactivex.Observer;
 import io.reactivex.annotations.*;
 import io.reactivex.exceptions.*;
 import io.reactivex.flowables.ConnectableFlowable;
@@ -36,7 +39,7 @@
     static volatile Consumer<? super Throwable> errorHandler;
 
     @Nullable
-    static volatile Function<? super Runnable, ? extends Runnable> onScheduleHandler;
+    static volatile List<Function<? super Runnable, ? extends Runnable>> onScheduleHandler = new ArrayList<Function<? super Runnable, ? extends Runnable>>();
 
     @Nullable
     static volatile Function<? super Callable<Scheduler>, ? extends Scheduler> onInitComputationHandler;
@@ -244,7 +247,7 @@
      * @return the hook function, may be null
      */
     @Nullable
-    public static Function<? super Runnable, ? extends Runnable> getScheduleHandler() {
+    public static List<Function<? super Runnable, ? extends Runnable>> getScheduleHandler() {
         return onScheduleHandler;
     }
 
@@ -446,11 +449,35 @@
      */
     @NonNull
     public static Runnable onSchedule(@NonNull Runnable run) {
-        Function<? super Runnable, ? extends Runnable> f = onScheduleHandler;
-        if (f == null) {
-            return run;
+
+        final List<Runnable> scheduledActions = new ArrayList<Runnable>();
+
+        /*
+         * Passing "empty" actions to all handlers but the last one.
+         * The last one should call an original action
+         */
+        Iterator<Function<? super Runnable, ? extends Runnable>> onScheduleIterator = onScheduleHandler.iterator();
+        while (onScheduleIterator.hasNext()) {
+            try {
+                scheduledActions.add(onScheduleIterator.next().apply(onScheduleIterator.hasNext() ? new Runnable() {
+                    @Override
+                    public void run() {
+                        // Does nothing, just a stub method
+                    }
+                } : run));
+            } catch (Exception ex) {
+                // Noting to do
+            }
         }
-        return apply(f, run);
+
+        return new Runnable() {
+            @Override
+            public void run() {
+                for (Runnable innerAction : scheduledActions) {
+                    innerAction.run();
+                }
+            }
+        };
     }
 
     /**
@@ -606,7 +633,7 @@
         if (lockdown) {
             throw new IllegalStateException("Plugins can't be changed anymore");
         }
-        onScheduleHandler = handler;
+        onScheduleHandler.add(handler);
     }
 
     /**

[akarnokd]

You should write a small library that manages multiple handles for you which you can depend on in your bundles.

The proper management of multiple handlers is non trivial as you have to consider concurrent access, ordering of the handlers as well as the infrastructure impact.

It should be up to developer to understand the performance impact and take care of it.

Since the scheduler hook is a core hook, it affects all users and leaves not much choice to avoid the overhead when there is no hook present. Your patch adds a lot of overhead even if there are no handles, plus it changes existing RxJavaPlugins API which is binary incompatible and not acceptable.

Also I’d reconsider using handlers in the first place as their primary purpose is to support testing and diagnostics, not resource-management or -tracking really.

[codefromthecrypt]

by the way, we’re trying to top-level some functionality to prevent the endless copy/paste https://github.com/openzipkin/brave/pull/665