Tips for creating a simulated asynchronous queue with blocking functionality in JavaScript or TypeScript

Question

Tips for creating a simulated asynchronous queue with blocking functionality in JavaScript or TypeScript

How about this for a paradox: I'm looking to develop an asynchronous blocking queue in JavaScript/TypeScript (or any other language if Typescript is not feasible). Essentially, I want to create something similar to Java's BlockingQueue, but instead of being truly blocking, it would function asynchronously and allow for awaiting dequeues.

Here's the outline of the interface I aim to build:

interface AsyncBlockingQueue<T> {
  enqueue(t: T): void;
  dequeue(): Promise<T>;
}

And here is how I envision using it:

// Enqueue items from another place

async function utilizeBlockingQueue() {
  // Once there is an item enqueued, the promise will be fulfilled:
  const value = await asyncBlockingQueue.dequeue();
  // This will prompt waiting for a second value
  const secondValue = await asyncBlockingQueue.dequeue();
}

Any suggestions?

javascript typescript asynchronous promise async-await

Answer 1

Answer №1

Quite straightforward, in essence, the dequeue function generates a promise that will be resolved by enqueue. The key lies in managing the resolvers in a queue, ensuring we handle scenarios where values are enqueued before dequeueing, and maintaining already fulfilled promises within a queue.

class AsyncBlockingQueue {
  constructor() {
    // Invariant: at least one of the arrays is empty
    this.resolvers = [];
    this.promises = [];
  }
  _add() {
    this.promises.push(new Promise(resolve => {
      this.resolvers.push(resolve);
    }));
  }
  enqueue(t) {
    if (!this.resolvers.length) this._add();
    this.resolvers.shift()(t);
  }
  dequeue() {
    if (!this.promises.length) this._add();
    return this.promises.shift();
  }
  // Additional utilities:
  isEmpty() { // Indicates no available values
    return !this.promises.length; // this.length <= 0
  }
  isBlocked() { // Indicates waiting for values
    return !!this.resolvers.length; // this.length < 0
  }
  get length() {
    return this.promises.length - this.resolvers.length;
  }
  [Symbol.asyncIterator]() {
    // Todo: Use AsyncIterator.from()
    return {
      next: () => this.dequeue().then(value => ({done: false, value})),
      [Symbol.asyncIterator]() { return this; },
    };
  }
}

I'm not familiar with TypeScript, but I assume adding the necessary type annotations would be straightforward.

For enhanced performance, consider implementing a Queue using circular buffers instead of regular arrays. Check out an option like this one. You may also opt to use a single queue and keep track of whether you are storing promises or resolvers at any given time.

Answer 2

Quite straightforward, in essence, the dequeue function generates a promise that will be resolved by enqueue. The key lies in managing the resolvers in a queue, ensuring we handle scenarios where values are enqueued before dequeueing, and maintaining already fulfilled promises within a queue.

class AsyncBlockingQueue {
  constructor() {
    // Invariant: at least one of the arrays is empty
    this.resolvers = [];
    this.promises = [];
  }
  _add() {
    this.promises.push(new Promise(resolve => {
      this.resolvers.push(resolve);
    }));
  }
  enqueue(t) {
    if (!this.resolvers.length) this._add();
    this.resolvers.shift()(t);
  }
  dequeue() {
    if (!this.promises.length) this._add();
    return this.promises.shift();
  }
  // Additional utilities:
  isEmpty() { // Indicates no available values
    return !this.promises.length; // this.length <= 0
  }
  isBlocked() { // Indicates waiting for values
    return !!this.resolvers.length; // this.length < 0
  }
  get length() {
    return this.promises.length - this.resolvers.length;
  }
  [Symbol.asyncIterator]() {
    // Todo: Use AsyncIterator.from()
    return {
      next: () => this.dequeue().then(value => ({done: false, value})),
      [Symbol.asyncIterator]() { return this; },
    };
  }
}

I'm not familiar with TypeScript, but I assume adding the necessary type annotations would be straightforward.

For enhanced performance, consider implementing a Queue using circular buffers instead of regular arrays. Check out an option like this one. You may also opt to use a single queue and keep track of whether you are storing promises or resolvers at any given time.

Tips for creating a simulated asynchronous queue with blocking functionality in JavaScript or TypeScript

Answer №1

Similar questions

Creating Class Names Dynamically in Angular 2 Using ngFor Index

What is the best method for displaying plain text using the br tag?

Ensuring that the field remains active in Angular2 even after editing it with a value

Using JavaScript to open a new window and display CSS while it loads

Is it recommended for synchronous code invoked by a Promise's .then method to generate a fresh Promise

What is the best way to transfer a variable from a Node.js Express server to an EJS HTML file in order to toggle alert visibility?

Struggling with Vue's Router Transition fade in/out effect not functioning as expected?

An efficient method for removing a column using JavaScript

A guide on incorporating a method using ES6 Rest into a JavaScript object

Conceal the Submit button upon completing the form submission using the load method

When comparing the results of running the NextJS build file and VS Code locally, there are noticeable discrepancies in

Display of Navigation Bar in Angular is Not Proper

Issue with TypeScript Decorator Not Properly Overriding Get/Set Functions for Instance Properties

Contact the help desk and receive information that is currently unknown

How can I use jQuery to locate all elements that match a specific style within the DOM?

Issue with data-ng-class function not being invoked

The Node.js application successfully receives an emit event from the browser, however, the browser does not receive any emit

How can I use React to switch the visibility of a nested component from the parent container component?

Currently, there is a requirement to include past build outcomes in the HTML test report within the playwright

Error encountered in Ubuntu while attempting to run a Python script within a Node.js/Express application: spawn EACCES