Pregunta de entrevista sobre manejo de concurrencia en Node JS.

Answer

1. 

   davy.ai

   August 2, 2023 at 4:20 am

   Para resolver este problema, necesitamos implementar un mecanismo de bloqueo para evitar la ejecución concurrente de la función update con el mismo parámetro id. Una forma de hacer esto es utilizando un hashmap y un cerrojo (mutex lock).

   Podemos crear un objeto hashmap accesible globalmente para almacenar el estado de los ids bloqueados. Cada vez que se llama a la función update, verificamos si el id ya está bloqueado. Si lo está, esperamos hasta que se libere el bloqueo antes de ejecutar la actualización. Si no lo está, adquirimos el bloqueo y procedemos con la actualización. Después de completar la actualización, liberamos el bloqueo para que las actualizaciones posteriores puedan ejecutarse.

   Aquí está el código modificado:

   const locks = {};
   
   async function update(id, data) {
     console.log(`inicio --> id:${id}, data:${data}`);
   
     if (locks[id]) {
       // el id está actualmente bloqueado, esperar hasta que se libere el bloqueo
       await locks[id];
     }
   
     // adquirir el bloqueo para este id
     const lock = new Promise(resolve => {
       locks[id] = resolve;
     });
   
     // ejecutar la actualización con un retraso aleatorio
     await randomDelay();
   
     console.log(`fin --> id:${id}, data:${data}`);
   
     // liberar el bloqueo para el id
     delete locks[id];
     lock.then(() => {});
   }
   
   //---- update() es llamado desde muchos lugares ----
   update(1, "navegador 1");
   update(1, "navegador 2");
   
   //========================= Funciones de utilidad ===================================
   //========================= No cambiar nada aquí ====================================
   
   async function sleep(ms) {
     return new Promise(resolve => {
       setTimeout(resolve, ms);
     });
   }
   
   async function randomDelay() {
     const randomTime = Math.round(Math.random() * 1000);
     return sleep(randomTime);
   }
   

   En este código modificado, primero definimos un objeto global locks para almacenar el estado de los ids bloqueados. La función update verifica si el id está bloqueado verificando si existe el valor locks[id]. Si existe, esperamos a que se libere el bloqueo usando await locks[id]. Una vez que se libera el bloqueo, procedemos a ejecutar la actualización. Antes de ejecutar la actualización, adquirimos el bloqueo para el id dado creando una nueva Promise y estableciéndola como el valor de locks[id]. Después de ejecutar la actualización, liberamos el bloqueo eliminando la entrada locks[id] y resolviendo la promesa del bloqueo con lock.then(() => {}).

   De esta manera, nos aseguramos de que las actualizaciones con el mismo parámetro id no se ejecuten de manera concurrente, sino que se ejecuten una a la vez en el orden en que se recibieron.

Comments are closed.