Issue
I follow a cleanup pattern in my Angular components that looks like this:
class SomeComponent implements OnInit, OnDestroy {
private destroy$ = new Subject();
ngOnInit() {
service.someStream().takeUntil(this.destroy$).subscribe(doSomething);
}
ngOnDestroy() {
this.destroy$.next(true);
}
}
This has the benefit of automatically unsubscribing when the component is destroyed.
My question is: Does a reference to destroy$
stick around indefinitely because I haven't called this.destroy$.complete()
, or will it get GC'ed when the parent class is collected?
Solution
If you look at the source for Subject.complete
, you'll find the answer:
complete() {
if (this.closed) {
throw new ObjectUnsubscribedError();
}
this.isStopped = true;
const { observers } = this;
const len = observers.length;
const copy = observers.slice();
for (let i = 0; i < len; i++) {
copy[i].complete();
}
this.observers.length = 0;
}
Calling complete
notifies any observers and then clears the array of observers. Unless you have an observer/subscriber that has a reference to the Subject
, there is nothing in the complete
implementation that would affect whether or not the Subject
could be garbage collected.
RxJS pushes notifications to subscribers. Subscribers don't hold references to the observables; it's the other way around. So, unless you've explicitly created a subscriber that holds a reference to the Subject
- via a closure or some other mechanism - there's no need to call complete
for garbage-collection purposes.
Answered By - cartant
0 comments:
Post a Comment
Note: Only a member of this blog may post a comment.