feat: 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 = 2000;
+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

@@ -11,12 +11,13 @@ const UNLOCKED = 1;
 let locks = null; // LockManager instance
 
 class Lock {
-  constructor(name, mode = 'exclusive', buffer = null) {
+  constructor({ name, mode = 'exclusive', buffer = null, timeout = null }) {
     this.name = name;
     this.mode = mode; // 'exclusive' or 'shared'
     this.queue = [];
     this.owner = false;
     this.trying = false;
+    this.timeout = timeout;
     this.buffer = buffer ? buffer : new SharedArrayBuffer(4);
     this.flag = new Int32Array(this.buffer, 0, 1);
     if (!buffer) Atomics.store(this.flag, 0, UNLOCKED);
@@ -39,10 +40,16 @@ class Lock {
     this.owner = true;
     this.trying = false;
     const { handler, resolve } = this.queue.shift();
-    handler(this).finally(() => {
+
+    const endWork = () => {
       this.leave();
       resolve();
-    });
+    };
+
+    if (typeof this.timeout === 'number') {
+      setTimeout(endWork, this.timeout);
+    }
+    handler(this).finally(endWork);
   }
 
   leave() {
@@ -89,11 +96,11 @@ 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) {
-      lock = new Lock(name, mode);
+      lock = new Lock({ name, mode, timeout });
       this.collection.set(name, lock);
       const { buffer } = lock;
       const message = { webLocks: true, kind: 'create', name, mode, buffer };
@@ -147,9 +154,9 @@ class LockManager {
 
   receive(message) {
     if (!message.webLocks) return;
-    const { kind, name, mode, buffer } = message;
+    const { kind, name, mode, buffer, timeout } = message;
     if (kind === 'create') {
-      const lock = new Lock(name, mode, buffer);
+      const lock = new Lock({ name, mode, buffer, timeout });
       this.collection.set(name, lock);
       return;
     }