Unsubscribing and memory leaks in Angular - Performance & Optimization

Performance: Unsubscribing and memory leaks

HIGH IMPACT

This concept affects the page's memory usage and responsiveness by preventing unnecessary background tasks and DOM updates.

Managing subscriptions to observables in Angular components

Angular

import { Component, OnInit, OnDestroy } from '@angular/core';
import { interval, Subscription } from 'rxjs';

@Component({ selector: 'app-good', template: '<p>Good example</p>' })
export class GoodComponent implements OnInit, OnDestroy {
  private sub?: Subscription;

  ngOnInit() {
    this.sub = interval(1000).subscribe(val => console.log(val));
  }

  ngOnDestroy() {
    this.sub?.unsubscribe();
  }
}

Unsubscribes on component destroy, freeing memory and stopping unnecessary event processing.

📈 Performance GainPrevents memory leaks and reduces INP by stopping background tasks when not needed.

Managing subscriptions to observables in Angular components

Angular

import { Component, OnInit } from '@angular/core';
import { interval } from 'rxjs';

@Component({ selector: 'app-bad', template: '<p>Bad example</p>' })
export class BadComponent implements OnInit {
  ngOnInit() {
    interval(1000).subscribe(val => console.log(val));
  }
}

Subscription is never unsubscribed, causing memory to grow and events to keep firing even after component destruction.

📉 Performance CostCauses memory leaks and increases INP by blocking main thread with unnecessary event handling.

Performance Comparison

Pattern	DOM Operations	Reflows	Paint Cost	Verdict
No unsubscribe	N/A (keeps event listeners active)	Triggers multiple reflows indirectly via change detection	Increased paint cost due to unnecessary updates	[X] Bad
Unsubscribe on destroy	No extra DOM operations after destroy	No reflows triggered after unsubscribe	Minimal paint cost after unsubscribe	[OK] Good

Rendering Pipeline

Subscriptions keep event listeners active, which can trigger change detection and DOM updates even when the component is not visible, increasing CPU and memory usage.

→JavaScript Execution

→Layout

→Paint

⚠️ BottleneckJavaScript Execution due to unnecessary event handling and change detection cycles

Core Web Vital Affected

INP

This concept affects the page's memory usage and responsiveness by preventing unnecessary background tasks and DOM updates.

Optimization Tips

1Always unsubscribe from observables in ngOnDestroy to prevent memory leaks.

2Use Angular's async pipe when possible to auto-manage subscriptions.

3Avoid long-running subscriptions that continue after component destruction.

Performance Quiz - 3 Questions

What is the main performance risk of not unsubscribing from observables in Angular components?

A Increased CSS paint time

B Memory leaks and slower input responsiveness

C Slower initial page load

D Longer network requests

DevTools: Performance

How to check: Record a performance profile while navigating to and from the component multiple times. Look for increasing memory usage or long scripting tasks after component destruction.

What to look for: Memory graph should not grow continuously; scripting time should drop after component is destroyed indicating no lingering subscriptions.

Practice

1. Why is it important to unsubscribe from Observables in Angular components?

easy

A. To make the component load faster initially.

B. To prevent memory leaks by stopping ongoing subscriptions when the component is destroyed.

C. To increase the number of active subscriptions.

D. To automatically refresh the component view.

Solution

1. Step 1: Understand Observable subscriptions

   Subscriptions keep listening to data streams, even if the component is gone.

2. Step 2: Recognize the effect of not unsubscribing

   Not unsubscribing causes memory to be used unnecessarily, leading to leaks.

3. Final Answer:

   To prevent memory leaks by stopping ongoing subscriptions when the component is destroyed. -> Option B

4. Quick Check:

   Unsubscribe to avoid memory leaks = B [OK]

Hint: Unsubscribe in ngOnDestroy to avoid leaks [OK]

Common Mistakes:

• Thinking Angular unsubscribes automatically
• Believing unsubscribing improves load speed
• Ignoring memory leaks from active subscriptions

2. Which of the following is the correct way to unsubscribe from a subscription in Angular's ngOnDestroy method?

easy

A. this.subscription.unsubscribe();

B. this.subscription.stop();

C. this.subscription.close();

D. this.subscription.cancel();

Solution

1. Step 1: Recall Subscription API

   The Subscription object has an unsubscribe() method to stop listening.

2. Step 2: Identify correct method name

   Only unsubscribe() is valid; others do not exist on Subscription.

3. Final Answer:

   this.subscription.unsubscribe(); -> Option A

4. Quick Check:

   Use unsubscribe() to stop subscription = D [OK]

Hint: Use unsubscribe() method to stop subscriptions [OK]

Common Mistakes:

• Using non-existent methods like stop() or cancel()
• Forgetting to call unsubscribe() at all
• Calling unsubscribe() outside ngOnDestroy

3. Consider this Angular component snippet:

export class MyComponent implements OnDestroy {
  private sub = this.service.getData().subscribe(data => console.log(data));

  ngOnDestroy() {
    // missing unsubscribe
  }
}

What will happen if this component is created and destroyed multiple times without adding unsubscribe in ngOnDestroy?

medium

A. Memory usage will increase over time due to active subscriptions not being cleaned up.

B. The component will automatically unsubscribe, so no issues occur.

C. The subscription will throw an error immediately on component destroy.

D. The component will reload data only once and then stop.

Solution

1. Step 1: Analyze missing unsubscribe

   Without calling unsubscribe, the subscription stays active even after component destruction.

2. Step 2: Understand consequences

   Repeated creation and destruction cause multiple active subscriptions, increasing memory use.

3. Final Answer:

   Memory usage will increase over time due to active subscriptions not being cleaned up. -> Option A

4. Quick Check:

   Missing unsubscribe causes memory leaks = A [OK]

Hint: No unsubscribe means memory leaks grow with component reuse [OK]

Common Mistakes:

• Assuming Angular auto-unsubscribes
• Expecting errors on destroy without unsubscribe
• Thinking subscription stops automatically

4. Identify the problem in this Angular component code related to unsubscribing:

export class DemoComponent implements OnDestroy {
  private subscription: Subscription;

  ngOnInit() {
    this.subscription = this.service.getData().subscribe();
  }

  ngOnDestroy() {
    this.subscription.unsubscribe;
  }
}

medium

A. The subscription is unsubscribed twice.

B. Subscription is declared but never assigned.

C. ngOnDestroy is missing the unsubscribe call.

D. The unsubscribe method is not called; it is referenced without parentheses.

Solution

1. Step 1: Check unsubscribe usage

   The code uses this.subscription.unsubscribe; without parentheses, so the method is not executed.

2. Step 2: Understand effect

   Without calling unsubscribe(), the subscription remains active, causing memory leaks.

3. Final Answer:

   The unsubscribe method is not called; it is referenced without parentheses. -> Option D

4. Quick Check:

   Call unsubscribe() with () to execute it = A [OK]

Hint: Always call unsubscribe() with parentheses [OK]

Common Mistakes:

• Forgetting parentheses on unsubscribe
• Assuming referencing method unsubscribes
• Not assigning subscription before unsubscribe

5. You have multiple subscriptions in an Angular component. Which is the best way to manage unsubscribing all of them efficiently?

hard

A. Ignore unsubscribing because Angular handles it automatically.

B. Manually call unsubscribe() on each subscription separately in ngOnDestroy.

C. Store all subscriptions in a Subscription object and call unsubscribe() once in ngOnDestroy.

D. Use setTimeout to delay unsubscribing after component destruction.

Solution

1. Step 1: Understand managing multiple subscriptions

   Using a Subscription object lets you add multiple subscriptions and unsubscribe all at once.

2. Step 2: Compare with manual unsubscribing

   Manual unsubscribing is error-prone and verbose; Subscription.add() simplifies cleanup.

3. Final Answer:

   Store all subscriptions in a Subscription object and call unsubscribe() once in ngOnDestroy. -> Option C

4. Quick Check:

   Use Subscription.add() and one unsubscribe() call = C [OK]

Hint: Use Subscription.add() to group and unsubscribe once [OK]

Common Mistakes:

• Forgetting to unsubscribe all subscriptions
• Relying on Angular to auto-unsubscribe
• Using setTimeout which delays cleanup unnecessarily