How To Delay Observable emission in RxJava

Question

We have Micro services architecture, where we make inter-service calls over a network. We are using RxJava in top level service, which is resulting in creation of large no of parallel requests to bottom service. Because of this i am getting "No Route to Host error" or "connection error". For that purpose i want to slow down emission from RxJava Observable, so that earlier connection will get closed before creating new one. Below is the sample code:

    package com.demo.rxjava.rxjaxa.creation;
    import rx.Observable;
    import rx.Subscriber;
    import rx.schedulers.Schedulers;

    public class Delay {

        public static void main(String[] args) throws InterruptedException {
            Observable.just(1, 2, 3, 4, 5).subscribeOn(Schedulers.io())
                    .flatMap(integer -> {
                        return function1(integer);
                    }).observeOn(Schedulers.io())
                    .subscribe(new Subscriber<String>() {
                        @Override
                        public void onNext(String item) {
                            System.out.println("Next: " + item);
                        }

                        @Override
                        public void onError(Throwable error) {
                            System.err.println("Error: " + error.getMessage());
                        }

                        @Override
                        public void onCompleted() {
                            System.out.println("Sequence complete.");
                        }
                    });
        }

     public Observable<String> function1(String id) {
                // This is where we make network call
                Observable<Response> response = Rx.newClient(RxObservableInvoker.class)
                        .target("http://example.com/resource")
                        .request()
                        .queryParam("id", id)
                        .rx()
                        .get();
                response.obserOn(Schedulers.from(threadExecutor)).flatMap(response->{
                    return response.extractResponse();
                });
   }
}

paul · Answer 1 · 2016-07-03T11:34:28.863

0

In order to delay a particular step you can use zip and combine that every item emitted in your first Observable.from go with an interval of X time.

   /**
 * If we want to delay the every single item emitted in the pipeline we will need a hack,
 * one possible hack is use zip operator and combine every item emitted with an interval so every item emitted has to wait until interval emit the item.
 */
@Test
public void delay() {
    long start = System.currentTimeMillis();
    Subscription subscription = Observable.zip(Observable.from(Arrays.asList(1, 2, 3)), Observable.interval(200, TimeUnit.MILLISECONDS), (i, t) -> i)
                                          .subscribe(n -> System.out.println("time:" + (System.currentTimeMillis() - start)));
    new TestSubscriber((Observer) subscription).awaitTerminalEvent(3000, TimeUnit.MILLISECONDS);
}

This will print

   time:537
   time:738
   time:936

More practicle examples here https://github.com/politrons/reactive

edited Jul 03 '16 at 11:34

answered Jul 02 '16 at 23:48

paul

12,873
23
91
153

This will only delay start of the emission, i want to delay each emission of observable by specific interval. – Ranjit Shinde Jul 03 '16 at 07:57
Check my new response – paul Jul 03 '16 at 11:21
It works, but on production code it is giving missing Back pressure error. – Ranjit Shinde Jul 03 '16 at 13:47
as per documentation "The zip operator uses reactive pull backpressure technique" but i guess its not working. – Ranjit Shinde Jul 03 '16 at 14:05

score 0 · Answer 2 · answered Jul 03 '16 at 10:40

0

Rather than delaying your requests you should have the requests to the bottom service occur on a Scheduler that limits parallel activity. For example:

 int maxParallel = 4;
 Scheduler scheduler = Schedulers.from(
     Executors.newFixedThreadPool(maxParallel));
 ...
 observable
   .flatMap(x -> 
       submitToBottomService(x)
         .subscribeOn(scheduler))
   .subscribe(subscriber);

By the way you mention closing a connection. The Observable.using operator is designed for closing resources in a reactive context (it closes resources on termination and unsubscription). If you are not using it yet then give it a look.

answered Jul 03 '16 at 10:40

Dave Moten

11,957
2
40
47

We are running bottom service call on Scheduler however we are creating async call to bottom service, so it is creating lot of connection ever before first call returns result. – Ranjit Shinde Jul 03 '16 at 13:44
the async call should be made using the scheduler, would you like to provide more code? – Dave Moten Jul 04 '16 at 07:52
I can't share the original code but updated question with the sudo code – Ranjit Shinde Jul 04 '16 at 12:42

How To Delay Observable emission in RxJava

2 Answers2