p-limit vs async-mutex vs async-lock vs async-sema vs semaphore-async-await | Comparación de paquetes npm de "Control de Concurrencia en JavaScript"

Paquete	Descargas	Stars	Tamaño	Issues	Publicación	Licencia

p-limit	184,743,681	2,373	10.3 kB	9	hace 6 meses	MIT
async-mutex	3,747,172	1,283	63 kB	14	hace un año	MIT
async-lock	2,697,312	412	18.3 kB	6	hace un año	MIT
async-sema	2,542,418	645	-	9	hace 4 años	MIT
semaphore-async-await	287,941	101	-	2	hace 8 años	MIT

Paquete

Descargas

Stars

Tamaño

Issues

Publicación

Licencia

p-limit

184,743,681

2,373

10.3 kB

hace 6 meses

MIT

async-mutex

3,747,172

1,283

63 kB

hace un año

MIT

async-lock

2,697,312

412

18.3 kB

hace un año

MIT

async-sema

2,542,418

645

hace 4 años

MIT

semaphore-async-await

287,941

101

hace 8 años

MIT

Tipo de Control de Concurrencia

p-limit:
p-limit no utiliza cerrojos ni semáforos, sino que limita el número de promesas que se ejecutan simultáneamente en un conjunto de tareas. Esto ayuda a controlar la carga en recursos externos sin necesidad de un control de concurrencia más complejo.
async-mutex:
async-mutex proporciona cerrojos (mutex) y semáforos (semaphores) para controlar el acceso a recursos compartidos. Los cerrojos permiten que solo una tarea acceda a un recurso a la vez, mientras que los semáforos permiten que un número limitado de tareas acceda al recurso simultáneamente.
async-lock:
async-lock utiliza cerrojos (locks) para garantizar que solo una tarea pueda acceder a una sección crítica del código a la vez. Esto se logra mediante la creación de un cerrojo que se adquiere antes de ejecutar la tarea y se libera una vez que la tarea ha finalizado.
async-sema:
async-sema se centra en la implementación de semáforos, que permiten que un número limitado de tareas acceda a un recurso al mismo tiempo. Esto es útil para controlar la concurrencia y evitar la sobrecarga de recursos.
semaphore-async-await:
semaphore-async-await utiliza semáforos para controlar el acceso a recursos compartidos. Proporciona una interfaz simple y clara para adquirir y liberar permisos, lo que facilita el control de la concurrencia en el código.

Facilidad de Uso

p-limit:
p-limit es extremadamente fácil de usar y se integra bien con la sintaxis de promesas. Solo necesitas especificar el límite de concurrencia y envolver tus tareas en la función p-limit.
async-mutex:
async-mutex ofrece una API clara para trabajar con cerrojos y semáforos, pero puede requerir un poco más de tiempo para entender todas sus características y opciones.
async-lock:
async-lock es muy fácil de usar y requiere poca configuración. Simplemente se crea un cerrojo y se utiliza para envolver la tarea que necesita ser protegida.
async-sema:
async-sema tiene una API simple y directa para trabajar con semáforos, lo que la hace fácil de usar para tareas que requieren un control de concurrencia básico.
semaphore-async-await:
semaphore-async-await proporciona una API intuitiva para trabajar con semáforos en un estilo async/await, lo que la hace fácil de usar para desarrolladores familiarizados con esta sintaxis.

Ejemplo de Código

p-limit:

Ejemplo de uso de p-limit

const pLimit = require('p-limit');
const limit = pLimit(2); // Limita a 2 promesas simultáneas

let sharedResource = 0;

const tasks = Array.from({ length: 4 }, (_, i) => limit(async () => {
  const temp = sharedResource;
  await new Promise(resolve => setTimeout(resolve, 100)); // Simula una operación asíncrona
  sharedResource = temp + 1;
}));

(async () => {
  await Promise.all(tasks);
  console.log(sharedResource); // Debería imprimir 4
});

async-mutex:

Ejemplo de uso de async-mutex

const { Mutex } = require('async-mutex');
const mutex = new Mutex();

let sharedResource = 0;

async function safeIncrement() {
  const release = await mutex.acquire();
  try {
    const temp = sharedResource;
    await new Promise(resolve => setTimeout(resolve, 100)); // Simula una operación asíncrona
    sharedResource = temp + 1;
  } finally {
    release(); // Libera el cerrojo
  }
}

(async () => {
  await Promise.all([safeIncrement(), safeIncrement(), safeIncrement()]);
  console.log(sharedResource); // Debería imprimir 3
});

async-lock:

Ejemplo de uso de async-lock

const AsyncLock = require('async-lock');
const lock = new AsyncLock();

let sharedResource = 0;

function incrementResource() {
  return lock.acquire('key', async () => {
    const temp = sharedResource;
    await new Promise(resolve => setTimeout(resolve, 100)); // Simula una operación asíncrona
    sharedResource = temp + 1;
  });
}

(async () => {
  await Promise.all([incrementResource(), incrementResource(), incrementResource()]);
  console.log(sharedResource); // Debería imprimir 3
});

async-sema:

Ejemplo de uso de async-sema

const { Sema } = require('async-sema');
const sema = new Sema(2); // Permite 2 tareas simultáneas

let sharedResource = 0;

async function limitedIncrement() {
  await sema.acquire();
  try {
    const temp = sharedResource;
    await new Promise(resolve => setTimeout(resolve, 100)); // Simula una operación asíncrona
    sharedResource = temp + 1;
  } finally {
    sema.release(); // Libera un permiso
  }
}

(async () => {
  await Promise.all([limitedIncrement(), limitedIncrement(), limitedIncrement(), limitedIncrement()]);
  console.log(sharedResource); // Debería imprimir 4
});

semaphore-async-await:

Ejemplo de uso de semaphore-async-await

const { Semaphore } = require('semaphore-async-await');
const semaphore = new Semaphore(2); // Permite 2 tareas simultáneas

let sharedResource = 0;

async function controlledIncrement() {
  await semaphore.acquire();
  try {
    const temp = sharedResource;
    await new Promise(resolve => setTimeout(resolve, 100)); // Simula una operación asíncrona
    sharedResource = temp + 1;
  } finally {
    semaphore.release(); // Libera un permiso
  }
}

(async () => {
  await Promise.all([controlledIncrement(), controlledIncrement(), controlledIncrement(), controlledIncrement()]);
  console.log(sharedResource); // Debería imprimir 4
});