Mutex

mutex.js

/* @flow */

class Lock {
 release: () => void
 sustain = new Promise<void>(resolve => {
  this.release = resolve
 })
}
export type Releaser<Key> = Promise<() => void>

export class LockPack<Key> {
 lockPromises: Map<Key, Promise<void>> = new Map()
 RELEASER_KEY = Symbol('releaser key')
 cleanup(releaser: Releaser<Key>) {
  this.lockPromises.delete((releaser: any)[this.RELEASER_KEY])
 }
 /**
  * Acquires a mutex lock over the given key. If the lock can't be acquired, it waits until it's available.
  * @param key Key to get the lock for.
  * @return {Promise.<() => void>} A Promise that resolves when the lock is acquired, with the function that
  * must be called to release the lock.
  */
 lock(key: Key): Releaser<Key> {
  const lock = new Lock()
  const lockPromise = this.lockPromises.get(key) || Promise.resolve()
  const releaser = lockPromise.then(() => lock.release)
  const sustain = lockPromise.then(() => lock.sustain)
  this.lockPromises.set(key, sustain)
  ;(releaser: any)[this.RELEASER_KEY] = key
  return releaser
 }
}

export default new LockPack<any>()