feat(mutex): add the mutex implementation

Author: Mendes Hugo

src/mutex/mutex.spec.ts

@@ -30,6 +30,9 @@ describe("Mutex", () => {
 			expect(mutex.isLocked).toBeFalse();
 			expect(mutex.queueLength).toBe(0);
 
+			// Lock a first time
+			await mutex.lock();
+
 			const [elapsed] = await timeFunction(async () => {
 				setTimeout(() => {
 					expect(mutex.isLocked).toBeTrue();
@@ -50,6 +53,9 @@ describe("Mutex", () => {
 		it("should work with many lock", async () => {
 			const mutex = new Mutex();
 
+			// Lock a first time
+			await mutex.lock();
+
 			const min = delay / 2;
 			const med = delay;
 			const max = delay * 2;
@@ -113,6 +119,9 @@ describe("Mutex", () => {
 		it("should work with tryLock/unlock", async () => {
 			const mutex = new Mutex();
 
+			// Lock a first time
+			await mutex.lock();
+
 			const [elapsed] = await timeFunction(async () => {
 				setTimeout(() => mutex.unlock(), delay);
 				await mutex.tryLock(delay * 5);
@@ -125,6 +134,9 @@ describe("Mutex", () => {
 		it("should thrown an error when the time exceeds", async () => {
 			const mutex = new Mutex();
 
+			// Lock a first time
+			await mutex.lock();
+
 			setTimeout(() => {
 				expect(mutex.queueLength).toBe(1);
 				expect(mutex.isLocked).toBeTrue();
@@ -145,6 +157,9 @@ describe("Mutex", () => {
 		const mutex = new Mutex();
 		const reason = "test";
 
+		// Lock a first time
+		await mutex.lock();
+
 		setTimeout(() => {
 			expect(mutex.isLocked).toBeTrue();
 			expect(mutex.queueLength).toBe(3);

src/mutex/mutex.ts

@@ -1,52 +1,70 @@
+import { Semaphore } from "../semaphore";
 import { Synchronizer } from "../synchronizer.interface";
 
+/**
+ * A mutex to manage "concurrency in Javascript" (as mentioned in the mozilla documentation).
+ *
+ * Implementation's note: the mutex simply use an internal semaphore.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise#promise_concurrency
+ */
 export class Mutex implements Synchronizer {
+	/**
+	 * The internal semaphore for mutex implementation
+	 */
+	private readonly semaphore = new Semaphore(1);
+
 	/**
 	 * @returns if the current mutex is currently locked
 	 */
 	public get isLocked(): boolean {
-		throw new Error("Not implemented yet");
+		return this.queueLength !== 0;
 	}
 
 	/**
 	 * @inheritDoc
 	 */
 	public get queueLength(): number {
-		throw new Error("Not implemented yet");
+		return this.semaphore.queueLength;
 	}
 
 	/**
 	 * Locks this mutex
 	 *
+	 * @throws {ConcurrencyInterruptedException} when the mutex is interrupted
 	 * @returns a promise when the lock has been set
 	 */
 	public lock(): Promise<void> {
-		throw new Error("Not implemented yet");
+		return this.semaphore.acquire(1);
 	}
 
 	/**
-	 * Locks this mutex within a time limit.
+	 * Locks this mutex within a time limit
 	 *
-	 * Throws an error if the given time exceeds.
+	 * Throws an error if the given time exceeds
 	 *
 	 * @param timeout maximum time (in ms) to lock
+	 * @throws {ConcurrencyExceedTimeoutException} when the time limit exceeds
+	 * @throws {ConcurrencyInterruptedException} when the mutex is interrupted
 	 * @returns a promise when the lock has been set
 	 */
 	public tryLock(timeout: number): Promise<void> {
-		throw new Error("Not implemented yet");
+		return this.semaphore.tryAcquire(timeout, 1);
 	}
 
 	/**
 	 * Unlocks this mutex
 	 */
 	public unlock() {
-		throw new Error("Not implemented yet");
+		this.semaphore.release();
 	}
 
 	/**
-	 * @inheritDoc
+	 * Interrupts all awaiting "Threads" with an [exception]{@link ConcurrencyInterruptedException}.
+	 *
+	 * @param reason The reason why this mutex is being interrupted
 	 */
 	public interrupt(reason: unknown) {
-		throw new Error("Not implemented yet");
+		this.semaphore.interrupt(reason, 1);
 	}
 }

src/synchronizer.interface.ts

@@ -1,3 +1,6 @@
+/**
+ * A synchronizer is an object or class that helps managing concurrency
+ */
 export interface Synchronizer {
 	/**
 	 * Interrupts all awaiting "Threads" with an [exception]{@link ConcurrencyInterruptedException}.