Will the Observable stop emitting midway in this scenario due to being garbage collected?

Question

I was wondering if the observable is eligible to be garbage collected in this scenario:

fun getObservable() = Observable.interval(500, TimeUnit.Milliseconds)

fun main(args: Array<String>) {
    getObservable().subscribe { println(it) }

    //Just to be able to observe the output.
    Thread.sleep(20*1000)
}

It doesn't stop emitting. But I can't use it to be sure that it will not be GC'd after some time since it may just be that GC isn't triggering in this short span.

My guess is that it should be GC'd. We don't have a reference to the Observable returned from the getObservable() function since we can't access it anymore. Calling the function again will give a different new Observable. Since we can't reach the Observable itself, the rest of the objects are also unreachable. So, I think all of this can be garbage collected at any random time.

Some of my code in an Android App uses somewhat similar code. And it is an Observable that I hope will last as long as the Application. Since, GC will collect any garbage, I don't want my Observable to be GC'd in the middle of my app. So, please keep that in mind that I'm not looking for answers telling me whether it will be GC'd or not. What I care about is whether it can be GC'd.

Thank you for taking out your time to help me.

EDIT: To make the context clearer, here's the basic idea of the concerned code as I use it in my app.

Repository.kt:

interface Repository {

    //Other code.

    fun getUserPrefs(): Flowable<UserPreference>
}

MyViewModel.kt:

class MyViewModel(private val repository: Repository): ViewModel() {

    init {
        repository.getUserPrefs()
            .subscribe { //Code with UI state side effects }
    }
}

In my app, Repository's implementation will be a singleton.For those not familiar with Android, just know that ViewModel's can last for pretty long time. It's work is basically to be responsible for managing UI state.

Answer 1

So after the sleep main exits and the emitting stops. If you try it with Thread.sleep(1000) you'll see that it only outputs

0
1

The reason for this is that your program terminates.

What you want here might be blockingSubscribe:

getObservable().blockingSubscribe { println(it) }

which will only return once the Observable is finished.

Note that you can subscribe on 3 types of events: onNext, onError and onComplete:

getObservable().blockingSubscribe({
    println(it)
}, {
    throw it
}, {
    println("finished")
})

Subscribing to all 3 will not change the fact that the subscriber runs out of scope so you'll still need to use blockingSubscribe. If you want to offload work between threads you can use subscribeOn and observeOn:

getObservable()
        .subscribeOn(Schedulers.computation())
        .observeOn(Schedulers.single())
        .blockingSubscribe {
            println(it)
        }

You can read more about these in this question.

About garbage collection:

The Java garbage collector is intelligent enough to reclaim resources which have references to each other but are not referenced by the so called "root reference":

 (Root reference)

 (obj0) --> (obj1)
  \          /
   \        /
    \      /
    (obj2)

^^^--- obj0, 1 and 2 are eligible for garbage collection

So why does your Observable keep running despite it being detached from other objects? The answer is that there are multiple types of "root" references in Java:

• Local variables
• Active Java threads
• Static variables
• JNI References

In your case when you call subscribe on your Observable it offloads work to RxJava-s threads which are "root" references in themselves so even if you don't have a reference of any of those objects they will still keep running ad infinitum or until the Threads terminate.