@types/async-lock

What is @types/async-lock?

@types/async-lock provides TypeScript type definitions for the async-lock library, which is used to manage asynchronous locks in JavaScript. This package helps ensure that your code is type-safe when using async-lock.

What are @types/async-lock's main functionalities?

Basic Locking

This feature allows you to create a lock on a specific key, ensuring that the critical section of code is executed exclusively.

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

lock.acquire('key', function(done) {
    // Critical section
    console.log('Locked section');
    done();
}, function(err, ret) {
    // Lock released
    console.log('Lock released');
});

Timeouts

This feature allows you to set a timeout for the lock. If the lock is not acquired within the specified time, an error is returned.

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

lock.acquire('key', function(done) {
    // Critical section
    setTimeout(() => {
        console.log('Locked section with timeout');
        done();
    }, 2000);
}, { timeout: 1000 }, function(err, ret) {
    if (err) {
        console.log('Lock timeout');
    } else {
        console.log('Lock released');
    }
});

Multiple Keys

This feature allows you to acquire locks on multiple keys simultaneously, ensuring that the critical section is executed only when all specified keys are locked.

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

lock.acquire(['key1', 'key2'], function(done) {
    // Critical section
    console.log('Locked section with multiple keys');
    done();
}, function(err, ret) {
    // Lock released
    console.log('Lock released');
});

Other packages similar to @types/async-lock

async-mutex

async-mutex provides a similar functionality to async-lock by offering mutexes and read-write locks for asynchronous code. It is simpler and more focused on mutexes compared to async-lock.

semaphore-async-await

semaphore-async-await provides semaphore and mutex implementations for async/await in JavaScript. It offers more advanced synchronization primitives compared to async-lock.

await-lock

await-lock is a lightweight implementation of a lock for async/await. It is simpler and more lightweight compared to async-lock, focusing solely on providing a basic lock mechanism.

README

Installation

npm install --save @types/async-lock

Summary

This package contains type definitions for async-lock (https://github.com/rain1017/async-lock).

Details

Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/async-lock.

Additional Details

• Last updated: Mon, 06 Nov 2023 22:41:04 GMT
• Dependencies: none

Credits

These definitions were written by Alejandro, Anatoly, Humulus, and BendingBender.