RXJava Observable onNext 在不同线程上发出

Question

If i try to emit onNext on different thread's, on subscribing it dosent catch the stream on next elements.

public static Observable<Student> getStudents()
{
    return Observable.create(e -> {

          for(int i : Arrays.asList(1,2,3))
          {
              Thread t = new Thread(() -> {

                  e.onNext(new Student("anirba", i));

              });
              t.start();
          }
          e.onComplete();
    });
}

On sunbscribing to this observable i dont get any response enter code here

Observable<Student> observer = getStudents();

    observer.subscribe(i -> System.out.println(i));

Answer 1

You are creating three threads inside the create method and each is adding an object of Student to stream. The reason why you are not getting any output is all these three threads will be running independently and based on thread scheduler it will be executed. In your case, the onComplete() method might get called before all these three threads add data into the Observable stream. and on-call of onComplete, the stream will be closed and no more data will be accepted by the stream. To make it work just to the below changes, it should work as you are expecting.

public static Observable<Student> getStudents() {
    return Observable.create(e -> {
          for(int i : Arrays.asList(1,2,3)) {
              Thread t = new Thread(() -> {
                  e.onNext(new Student("anirba", i));
              });
              t.start();
          }
          Thread.sleep(1000);
          e.onComplete();
    });
}

Answer 2

java.util.concurrent.Executor is the right API now for running tasks. To block the current thread you can use CountDownLatch and release it when all tasks are terminated.

ExecutorService executor = Executors.newCachedThreadPool(); // choose the right one

public Observable<Student> getStudents() {
    return Observable.<Student>create(emitter -> {
        List<Integer> source = Arrays.asList(1, 2, 3);
        CountDownLatch latch = new CountDownLatch(source.size());

        source
                .forEach(i ->
                        executor.submit(() -> {
                            emitter.onNext(new Student("anirba", i));
                            latch.countDown();
                        }));

        latch.await();
        emitter.onComplete();
    }).serialize();
}

And elsewhere don't forget to call shutdown() on the executor .

You may also add serialize() operator to avoid onnext() calls to overlap.

From the contract :

Observables must issue notifications to observers serially (not in parallel). They may issue these notifications from different threads, but there must be a formal happens-before relationship between the notifications.

For the perpose of testing you can add Thread.sleep(x) to see your loggin. I've already answerd this before here

public static void main(String[] args) throws InterruptedException {
     getStudents()
             .subscribe(i -> System.out.println(i));
    
    Thread.sleep(2000);
}