@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.

index.d.ts

// Type definitions for async-lock 1.1
// Project: https://github.com/rain1017/async-lock, https://github.com/rogierschouten/async-lock
// Definitions by: Alejandro <https://github.com/afharo>
//                 Anatoly <https://github.com/rhymmor>
//                 Humulus <https://github.com/humulus>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
// TypeScript Version: 2.1

type AsyncLockDoneCallback<T> = (err?: Error, ret?: T) => void;

interface AsyncLockOptions {
    timeout?: number | undefined;
    maxPending?: number | undefined;
    maxOccupationTime?: number | undefined;
    domainReentrant?: boolean | undefined;
    Promise?: any;
    skipQueue?: boolean | undefined;
}

declare class AsyncLock {
    constructor(options?: AsyncLockOptions);

    acquire<T>(key: string | string[],
               fn: (() => T | PromiseLike<T>) | ((done: AsyncLockDoneCallback<T>) => any),
               opts?: AsyncLockOptions): Promise<T>;
    acquire<T>(key: string | string[],
               fn: (done: AsyncLockDoneCallback<T>) => any,
               cb: AsyncLockDoneCallback<T>,
               opts?: AsyncLockOptions): void;

    isBusy(key?: string): boolean;
}

declare namespace AsyncLock { }

export = AsyncLock;

Additional Details

• Last updated: Fri, 15 Apr 2022 07:31:18 GMT
• Dependencies: none
• Global values: none

Credits

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