How best to release elements in a ReplaySubject?

Hi,

We’re using ReplaySubject to keep a streamed response from a server into a buffer, in order to be able to pass the whole (finite) sequence to observables that subscribe to the subject.

The whole sequence may take a bit of time to complete, but we want to pass the Observable right away to client code.Furthermore, client code may not immediately subscribe to the flow, or it could subscribe several time to do multiple processing of the sequence.

Thus the use of ReplaySubject to avoid replaying the original request each time, and to avoid blocking for the server to respond with the whole sequence.

However, said elements are resources that are reference counted and should be manually freed before being garbage collected. What do you think is the best approach to cope with that?

Maybe what we need is to add semantics on the ReplaySubject to do cleanup and clear the buffer (like a dispose() or release() method)? This would probably also be needed in the bounded ReplaySubject to plug in cleanup behavior at eviction time…

Maybe there is a better alternative to ReplaySubject? Or a simple solution like foreaching on the items and cleaning them up this way?

I hope someone will be able to make a suggestion, and I’d be delighted to contribute if it makes sense 😉 Thanks!

[benjchristensen]

Using Subjects directly are almost never the desired solution as they don’t compose with backpressure or resource cleanup (unsubscription). Subjects are very imperative in use and “hot” in how data flows through them.

For example, using cache() internally uses ReplaySubject but it will be garbage collected once references to the Observables are released. Or replay().refCount() is even better, as once all Subscribers are done it will unsubscribe up the chain and dispose of the underlying ReplaySubject.

Your use case however sounds like you should use Observable.create to represent your data source since then you can manage the cleanup as you need to (since you need to manage the reference counting).

Thus, I suggest something like the following:

import java.util.Arrays;
import java.util.Collection;

import rx.Observable;
import rx.schedulers.Schedulers;
import rx.subscriptions.Subscriptions;

public class ObservableCreateWithCleanup {

    public static void main(String[] args) {
        System.out.println("fetch slow data...");
        getData().toBlocking().forEach(System.out::println);
        // sleep so the JVM doesn't shut down before we see cleanup
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
        }
    }

    public static Observable<Data> getData() {
        return Observable.<Data> create(subscriber -> {
            try {
                Collection<Data> data = slowSynchronousCall();
                // completely ignoring backpressure and not using setProducer for simplicity here
                for(Data d : data) {
                    subscriber.onNext(d);
                }
                subscriber.onCompleted();
                // register subscription
                subscriber.add(Subscriptions.create(() -> {
                    try {
                        // do the manual refcount release
                        for(Data d : data) {
                            d.release();
                        }
                    }catch(Throwable e) {
                        // never throw while unsubscribing
                        e.printStackTrace();
                    }
                }));
            }catch(Throwable e) {
                subscriber.onError(e);
            }
        }).subscribeOn(Schedulers.io());
    }

    /**
     * Assuming the slow call is synchronous. And I'm making this be a single collection rather than a stream to the Observable.
     * 
     * @param id
     * @return
     */
    public static Collection<Data> slowSynchronousCall() {
        try {
            // simulate slow
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }
        return Arrays.asList(new Data(1), new Data(2), new Data(3));
    }

    public static class Data {
        private final int id;

        public Data(int id) {
            this.id = id;
        }

        public void release() {
            System.out.println("Releasing " + toString());
        }

        @Override
        public String toString() {
            return "Data => " + id;
        }
    }
}

This outputs:

fetch slow data...
Data => 1
Data => 2
Data => 3
Releasing Data => 1
Releasing Data => 2
Releasing Data => 3

[simonbasle]

getValues() right? awesome 😍