Locking timeout

errors.js

@@ -0,0 +1,20 @@
+'use strict';
+
+class AbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AbortError';
+  }
+}
+
+class TimeoutError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'TimeoutError';
+  }
+}
+
+module.exports = {
+  AbortError,
+  TimeoutError,
+};

test.js

@@ -8,6 +8,7 @@ const tests = [
   'deadlock',
   'recursive-deadlock',
   'thread-main',
+  'lock-time',
 ];
 
 (async () => {

test/lock-time.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const assert = require('assert').strict;
+const { locks } = require('..');
+const { sleep } = require('./test-utils.js');
+const { TimeoutError } = require('../errors.js');
+
+module.exports = async () => {
+  await (async () => {
+    const caseName = 'Should release a resource after timeout deadline';
+    const startTs = Date.now();
+
+    await locks
+      .request('LockTime', { timeout: 100 }, async () => {
+        await sleep(200);
+      })
+      .catch(() => {});
+
+    const isCaseSuccess = Date.now() - startTs < 200;
+    assert.strictEqual(isCaseSuccess, true, caseName);
+  })();
+
+  await (async () => {
+    const caseName = 'Should release a resource and throw the TimeoutError';
+    let error;
+
+    await locks
+      .request('LockTime', { timeout: 100 }, async () => {
+        await sleep(200);
+      })
+      .catch(err => (error = err));
+
+    const isCaseSuccess = error instanceof TimeoutError;
+    assert.strictEqual(isCaseSuccess, true, caseName);
+  })();
+
+  await (async () => {
+    const caseName = 'Should release a resource after handler complete a task';
+    const startTs = Date.now();
+
+    await locks.request('LockTime', { timeout: 200 }, async () => {
+      await sleep(100);
+    });
+
+    const isCaseSuccess = Date.now() - startTs < 200;
+    assert.strictEqual(isCaseSuccess, true, caseName);
+  })();
+};

test/steps.js

@@ -2,13 +2,7 @@
 
 const assert = require('assert').strict;
 const { locks } = require('..');
-
-const sleep = msec =>
-  new Promise(resolve => {
-    setTimeout(() => {
-      resolve();
-    }, msec);
-  });
+const { sleep } = require('./test-utils.js');
 
 let counter = 0;
 

test/test-utils.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const sleep = msec =>
+  new Promise(resolve => {
+    setTimeout(resolve, msec);
+  });
+
+module.exports = {
+  sleep,
+};

test/thread-worker.js

@@ -1,14 +1,10 @@
 'use strict';
 
 const threads = require('worker_threads');
+const { sleep } = require('./test-utils.js');
 
 const { locks } = require('..');
 
-const sleep = msec =>
-  new Promise(resolve => {
-    setTimeout(resolve, msec);
-  });
-
 (async () => {
   if (threads.threadId === 2) {
     await sleep(10);

web-locks.js

@@ -2,6 +2,7 @@
 
 const { EventEmitter } = require('events');
 const threads = require('worker_threads');
+const { AbortError, TimeoutError } = require('./errors');
 const { isMainThread, parentPort } = threads;
 const isWorkerThread = !isMainThread;
 
@@ -22,9 +23,9 @@ class Lock {
     if (!buffer) Atomics.store(this.flag, 0, UNLOCKED);
   }
 
-  enter(handler) {
-    return new Promise(resolve => {
-      this.queue.push({ handler, resolve });
+  enter(handler, timeout, signal) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ handler, resolve, reject, timeout, signal });
       this.trying = true;
       setTimeout(() => {
         this.tryEnter();
@@ -38,11 +39,25 @@ class Lock {
     if (prev === LOCKED) return;
     this.owner = true;
     this.trying = false;
-    const { handler, resolve } = this.queue.shift();
-    handler(this).finally(() => {
+    let timer;
+
+    const { handler, resolve, reject, timeout, signal } = this.queue.shift();
+
+    const finalize = error => {
       this.leave();
-      resolve();
-    });
+      if (timer !== undefined) {
+        clearTimeout(timer);
+        timer = undefined;
+      }
+      if (error) reject(error);
+      else resolve();
+    };
+
+    if (signal) signal.on('abort', finalize);
+    if (timeout)
+      timer = setTimeout(finalize, timeout, new TimeoutError('Time Out'));
+
+    handler(this).finally(finalize);
   }
 
   leave() {
@@ -89,7 +104,7 @@ class LockManager {
       handler = options;
       options = {};
     }
-    const { mode = 'exclusive', signal = null } = options;
+    const { mode = 'exclusive', signal = null, timeout } = options;
 
     let lock = this.collection.get(name);
     if (!lock) {
@@ -100,16 +115,9 @@ class LockManager {
       locks.send(message);
     }
 
-    const finished = lock.enter(handler);
-    let aborted = null;
-    if (signal) {
-      aborted = new Promise((resolve, reject) => {
-        signal.on('abort', reject);
-      });
-      await Promise.race([finished, aborted]);
-    } else {
-      await finished;
-    }
+    const finished = lock.enter(handler, timeout, signal);
+
+    await finished;
 
     setTimeout(() => {
       lock.tryEnter();
@@ -163,13 +171,6 @@ class LockManager {
   }
 }
 
-class AbortError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AbortError';
-  }
-}
-
 class AbortSignal extends EventEmitter {
   constructor() {
     super();