Concurrency Design Patterns

Concurrency Design Patterns are design patterns that address the issues of concurrency and parallelism in software systems. They provide solutions for managing shared resources, preventing deadlocks, and coordinating multiple threads or processes. There are several Concurrency Design Patterns, including:

1. Thread Pool Pattern: This pattern involves creating a group of threads in advance, which can be reused when needed. This is useful in situations where creating and destroying threads can be a performance bottleneck. An example of this pattern in JavaScript is the worker API, which creates a pool of worker threads to improve the performance of tasks that are computationally expensive.
2. Lock Pattern: This pattern involves using a mutex or a semaphore to provide mutually exclusive access to shared resources. By acquiring a lock, a thread or process can prevent other threads or processes from accessing the same resource simultaneously, preventing data races and other synchronization issues. An example of this pattern in JavaScript is the Lock API, which provides a simple way to acquire and release locks.
3. Monitor Pattern: This pattern involves using a monitor object to manage concurrent access to shared resources. The monitor object acts as a gatekeeper to the shared resource, allowing only one thread or process to access it at a time. This pattern is widely used in concurrent programming and is implemented in many programming languages, including JavaScript.
4. Read-Write Lock Pattern: This pattern involves using separate locks for read and write access to shared resources. By allowing multiple threads to read the resource simultaneously, this pattern can improve the performance of read-heavy applications. An example of this pattern in JavaScript is the ReaderWriterLock API, which allows you to acquire a lock for reading or writing.

Here’s an example of how the Thread Pool Pattern can be implemented in JavaScript:

// Creating a worker pool with the Worker API
const WORKER_COUNT = 4;

const workers = [];
for (let i = 0; i < WORKER_COUNT; i++) {
  const worker = new Worker('worker.js');
  workers.push(worker);
}

// Executing tasks with the worker pool
function executeTask(taskData) {
  return new Promise((resolve, reject) => {
    const worker = workers.find(w => w.busy === false);
    if (worker) {
      worker.busy = true;
      worker.postMessage(taskData);
      worker.addEventListener('message', event => {
        resolve(event.data.result);
        worker.busy = false;
      }, { once: true });
      worker.addEventListener('error', event => {
        reject(event.error);
        worker.busy = false;
      }, { once: true });
    } else {
      reject(new Error('All workers are busy. Please try again later.'));
    }
  });
}

// Task to execute in a worker thread
function fibonacci(n) {
  if (n <= 1) {
    return n;
  }
  return fibonacci(n - 1) + fibonacci(n - 2);
}

// Using the worker pool to execute the task
executeTask({ task: 'fibonacci', args: [40] })
  .then(result => console.log(result))
  .catch(error => console.error(error));

This example creates a pool of worker threads using the

Worker

API and assigns a task to an available worker when requested. The task in this example is the

fibonacci

function, which is computationally expensive and can benefit from parallel execution.

Get Anant Nema’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

The

executeTask

function checks if workers are available from the pool and assigns the task to the first free worker. When the worker completes the task, it sends back the result, which is resolved by the

Promise

returned by

executeTask

This approach allows us to execute multiple tasks simultaneously without creating and destroying threads, improving the performance of the application.