Question 234383 in Javascript Question posted in
A very good W3school tutorial can be found here.

Javascript – Will a never fulfilled promise cause a memory leak?

this question is not new on SO, but I have a scenario that is not exactly the same as other questions.

Let’s say I have a class Component

class Component {
  constructor() {
    this.resolvers = [];
  }

  addResolver() {
    return new Promise((resolve) => {
      this.resolvers.push(resolve);
    });
  }

  callResolvers() {
    this.resolvers.forEach((resolver) => resolver());
  }
}

Then I have this snippet of code

let components = [];

async function addComponent() {
  const component = new Component();

  components.push(component);

  await component.addResolver();

  console.log("resolver called");
}

function deleteComponents() {
  components = [];
}

function resolveComponents() {
  components.forEach((component) => component.callResolvers());
}

addComponent();
addComponent();
addComponent();

resolveComponents();

If I call resolveComponents() the resolvers are called.

My concern is if instead of resolveComponents(), I call deleteComponents(), like this:

addComponent();
addComponent();
addComponent();

deleteComponents();

Will that garbage collect the components?

They have unfulfilled promises, the resolvers for these promises are stored in the component.resolvers.

Since the previous components will be impossible to reach after the deletion, my guess is that they will be collected even though they have unfulfilled promises.

What’s the answer to this?

Tags:

3

Answers


  1. 0

    If there are not references to the promise, and it goes out of scope it will most likely be eligible for GC, although I’m not 100% certain that is the case. It is generally good practice to resolve any promises you have, so I’d suggest calling the resolvers before deleting the components.

    Login or Signup to reply.
  2. 0

    You have no circular dependencies, and calling deleteComponents lets go of the only reference you have to them. So the components won’t be leaked

    Login or Signup to reply.
  3. 0

    A Promise is just a regular object, so if there are no more references to it, then it gets cleared by the garbage collector (even if in pending state). If a Promise resolves later, then obviously there is a reference to it somewhere. For example in this code:

    new Promise(resolve => setTimeout(resolve, 999999));

    Even if we don’t store the Promise in a variable, setTimeout keeps a reference to the resolve function of the Promise instance during the delay, then the Promise instance is kept alive until the delay ends.

    In your example if you replace the components array with an empty one, the components can be garbage collected, along with their resolvers property which contains the only references to the Promises, so they can be collected as well.

    If you have doubts about memory leaks, you can diagnose them easily by taking a snapshot of the memory with the "memory" tab of the browser’s DevTools.

    Login or Signup to reply.
Please signup or login to give your own answer.

Back To Top
Search