1.2.7: replay(1).refCount() keeps latest value in memory even after everyone unsubscribes

[ZuZuK]

Code sample:

public class MainActivity extends AppCompatActivity {

    private Observable<Object> testObservable;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        testObservable = Observable.fromCallable(new Callable<Object>() {
            @Override
            public Object call() throws Exception {
                return new VeryBigObject();
            }
        })
        .replay(1)
        .refCount();

        //first subscription - callable and creation of VeryBigObject will be called
        Subscription subscription1 = testObservable.subscribe();
        //second subscription - cached value in OperatorReplay in onNext
        Subscription subscription2 = testObservable.subscribe();
        //first unsubscribe - cached value still in OperatorReplay as we have at least 1 subscriber for refCount
        subscription1.unsubscribe();
        //second unsubscribe - there are no subscribers so my guess is that there should be no cached value in OperatorReplay
        //as no one needs that object
        subscription2.unsubscribe();
        //but after everyone unsubscribe there is a reference to VeryBigObject
    }

    public static class VeryBigObject {
        //it's very big
    }

}

Problem: if I'm storing in field any Observable that contains replay(1).refCount() then this field will store hard reference to that latest value stored in replay buffer even if there are no subscriptions to that replay. This value takes memory and it is not good but maybe it's as-design. Also I think that this bug is actual for any replay(***) of any observables chain that have such operator.

Why am I sad: usually I use such construction to not calculate or get from disc some shared single-instance object so if there are at least one subscriber so that object is calculating on subscribe and other subscribers won't call calculation on subscribe but take already calculated value.

Reference to VeryBigObject

    from `MainActivity` - this (root) object
    from `testObservable (Observable)` - field of MainActivity object stores Observable with replay
    from `onSubscribe (OnSubscribeRefCount)` - field of testObservable stores refCount()
    from `source (OperatorReplay)` - field of OnSubscribeRefCount stores ConnectableObservable of replay()
     from `current (AtomicReference)` - reference to current subscriber, it is only changing to not-null in connect() of OperatorReplay
     from `value (OperatorReplay$ReplaySubscriber)` - value of AtomicReference
     from `buffer (OperatorReplay$SizeBoundReplayBuffer)` - linked list of replay values with limit=1. after everyone unsubscribe it has size=2 index=2
     from `value (OperatorReplay$Node)` - head node of linked list - it's own node value (not from AtomicReference field) is null
     from `value (OperatorReplay$Node)` - next element of linked list from head - it stores VeryBigObject
     from `value (VeryBigObject)` - latest value of replay(1) before everyone unsubscribe

[akarnokd]

Try with onTerminateDetach before the replay().

[ZuZuK]

@akarnokd onTerminateDetach not helping :(

• without detach it is SingleDelayedProducer in producer field of OperatorReplay$ReplaySubscriber and it have reference to OperatorReplay$ReplaySubscriber in child field;
• with detach it is OnSubscribeDetach$DetachProducer in producer field and there is no reference from that but there is still reference from value->current->source->onSubscribe->testObservable;

I mean I think problem is that on creation before someone subscribed there was null value of OperatorReplay->current but after everyone unsubscribed OperatorReplay didn't back to initial state with null in that field so it continue holding reference to OperatorReplay$ReplaySubscriber that was created on first subscription. and in OperatorReplay$ReplaySubscriber there is a buffer with leaked objects

if it could help there are heap .hprof files: (look for class test.activities.MainActivity$VeryBigObject)

• heap with onTerminateDetach: https://www.dropbox.com/s/5swiv6lk9oh8cnj/with_detach_2017.03.11_18.57.hprof?dl=0
• heap without onTerminateDetach: https://www.dropbox.com/s/j8hzxs7drqagxcr/without_detach_2017.03.11_18.5.hprof?dl=0

now few comments about onTerminateDetach - I saw it in discussion #4494 before.
and my opinion that onTerminateDetach won't help in described situation because on subscription of replay() it should subscribe to previous observable so it should be stored in source and if it is Observable.just(millionValues) then it should store millionValues to emit them to subscribers.
and I think if someone don't want to store it in memory then they could just use

Observable.fromCallable(()->Observable.just(millionValues)).switchMap(justObservable->justObservable).last().replay()
or use
Observable.switchOnNext(Observable.fromCallable(()->Observable.just(millionValues))).last().replay()

[akarnokd]

I see. Could you do a final test: use onTerminateDetach() after refCount() as well (so 2 of them total) and make sure the Subscriptions are nulled out before you take a heap dump?

[ZuZuK]

code and 4 dumps: line 30 (1_before_first_subscribe), line 32 (2_after_second_subscribe), line 34 (3_after_second_unsubscribe) and 4_after_on_create
https://www.dropbox.com/sh/y77sjnhu6smlxfp/AACq2WyFLqqsQTIgrw0aNnNBa?dl=0

[akarnokd]

In number 4. All I see is a small heap with barely anything in it:

[ZuZuK]

Don't think that profiler thinks that it is a problem until I'll put byte[1000000] or something like that inside VeryBigObject
But problem is that in number 4 there is strong reference to VeryBigObject and in number 1 there is no such reference

[akarnokd]

See #5181 for the fix.

[akarnokd]

Closing via #5181 & #5182.