Locking timeout

test.js

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

test/lock-time.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const assert = require('assert').strict;
+const { locks } = require('..');
+const { sleep } = require('./test-utils');
+
+const TIME_TO_PROCESS = 200;
+const TIME_TO_LOCK = 100;
+
+module.exports = async () => {
+  const startTs = Date.now();
+
+  await locks.request('LockTime', { timeout: TIME_TO_LOCK }, async () => {
+    await sleep(TIME_TO_PROCESS);
+  });
+
+  assert.strictEqual(Date.now() - startTs < TIME_TO_PROCESS, true);
+};

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');
 
 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');
 
 const { locks } = require('..');
 
-const sleep = msec =>
-  new Promise(resolve => {
-    setTimeout(resolve, msec);
-  });
-
 (async () => {
   if (threads.threadId === 2) {
     await sleep(10);

web-locks.js

@@ -22,9 +22,9 @@ class Lock {
     if (!buffer) Atomics.store(this.flag, 0, UNLOCKED);
   }
 
-  enter(handler) {
+  enter(handler, timeout) {
     return new Promise(resolve => {
-      this.queue.push({ handler, resolve });
+      this.queue.push({ handler, resolve, timeout });
       this.trying = true;
       setTimeout(() => {
         this.tryEnter();
@@ -38,11 +38,17 @@ class Lock {
     if (prev === LOCKED) return;
     this.owner = true;
     this.trying = false;
-    const { handler, resolve } = this.queue.shift();
-    handler(this).finally(() => {
+    const { handler, resolve, timeout } = this.queue.shift();
+
+    const endWork = () => {
       this.leave();
       resolve();
-    });
+    };
+
+    if (timeout) {
+      setTimeout(endWork, timeout);
+    }
+    handler(this).finally(endWork);
   }
 
   leave() {
@@ -89,7 +95,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,7 +106,7 @@ class LockManager {
       locks.send(message);
     }
 
-    const finished = lock.enter(handler);
+    const finished = lock.enter(handler, timeout);
     let aborted = null;
     if (signal) {
       aborted = new Promise((resolve, reject) => {