feat(RwLock): use RawSemaphore to improve performance

  benchmark      time (avg)        iter/s             (min … max)       p75       p99      p995
  --------------------------------------------------------------- -----------------------------

  group RwLock#lock
  current       270.64 µs/iter       3,695.0 (247.21 µs … 681.58 µs) 257.83 µs 508.83 µs 532.21 µs
  v1.0.0         52.87 ms/iter          18.9   (47.98 ms … 57.47 ms) 55.87 ms 57.47 ms 57.47 ms

  summary
    current
    195.35x faster than v1.0.0

  group RwLock#rlock
  current       201.44 µs/iter       4,964.4   (182.46 µs … 1.18 ms) 189.58 µs 445.92 µs 474.75 µs
  v1.0.0         57.84 ms/iter          17.3   (52.11 ms … 78.27 ms) 59.24 ms 78.27 ms 78.27 ms

  summary
    current
    287.13x faster than v1.0.0

Author: lambdalisue

rw_lock.ts

@@ -1,4 +1,4 @@
-import { Mutex } from "./mutex.ts";
+import { RawSemaphore } from "./_raw_semaphore.ts";
 
 /**
  * A reader-writer lock implementation that allows multiple concurrent reads but only one write at a time.
@@ -29,8 +29,8 @@ import { Mutex } from "./mutex.ts";
  * ```
  */
 export class RwLock<T> {
-  #read = new Mutex();
-  #write = new Mutex();
+  #read = new RawSemaphore(1);
+  #write = new RawSemaphore(1);
   #value: T;
 
   /**
@@ -50,16 +50,16 @@ export class RwLock<T> {
    * @returns A promise that resolves to the return value of the specified function.
    */
   async lock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    const wlock = await this.#write.acquire();
+    await this.#write.acquire();
     try {
-      const rlock = await this.#read.acquire();
+      await this.#read.acquire();
       try {
         return await fn(this.#value);
       } finally {
-        rlock[Symbol.dispose]();
+        this.#read.release();
       }
     } finally {
-      wlock[Symbol.dispose]();
+      this.#write.release();
     }
   }
 
@@ -71,19 +71,19 @@ export class RwLock<T> {
    * @returns A promise that resolves to the return value of the specified function.
    */
   async rlock<R>(fn: (value: T) => R | PromiseLike<R>): Promise<R> {
-    const wlock = this.#write.locked
-      ? await this.#write.acquire()
-      : { [Symbol.dispose]: () => {} };
+    if (this.#write.locked) {
+      await this.#write.acquire();
+    }
     try {
       // Acquire the read lock without waiting to allow multiple readers to access the lock.
-      const rlock = this.#read.acquire();
+      this.#read.acquire();
       try {
         return await fn(this.#value);
       } finally {
-        rlock[Symbol.dispose]();
+        this.#read.release();
       }
     } finally {
-      wlock[Symbol.dispose]();
+      this.#write.release();
     }
   }
 }