# rw-mutex-ts

> RWMutex - inspired by the one from Golang

Latest version **1.1.0** (published 2023-01-25) · ISC license · 0 weekly downloads

## Install

```sh
npm install rw-mutex-ts
pnpm add rw-mutex-ts
yarn add rw-mutex-ts
bun add rw-mutex-ts
```

## Health

**Score 15/100 (F)** — status: abandoned.

Positive: no vulnerabilities.

Warnings: low downloads; no types; no esm support.

Negative: abandoned; low maintenance score.

## Facts

| | |
|---|---|
| Version | 1.1.0 |
| Published | 2023-01-25 |
| First published | 2021-03-17 |
| Weekly downloads | 0 |
| License | ISC |
| TypeScript types | none |
| Module format | CommonJS |
| Dependencies | 0 |
| Unpacked size | 9.7 KB |
| Known vulnerabilities | 0 |
| Install scripts | no |
| GitHub stars | 1 |
| Author | xshkut |
| Maintainers | xshkut |

## Links

- npm: https://www.npmjs.com/package/rw-mutex-ts
- Repository: https://github.com/xshkut/rwmutex-js
- Homepage: https://github.com/xshkut/rwmutex-js#readme
- Issues: https://github.com/xshkut/rwmutex-js/issues
- npm.io page: https://npm.io/package/rw-mutex-ts

## Recent versions

- 1.1.0 (latest) — 2023-01-25
- 1.0.4 — 2022-06-03
- 1.0.2 — 2021-04-05
- 1.0.1 — 2021-03-17
- 1.0.0 — 2021-03-17

## README

# RW-MUTEX-TS

Read-write mutex is inspired by the one from Golang.
Written in Typescript.
Easy to use, flexible. Includes helper functions.

## Install

```
import { RWMutex } from 'rw-mutex-ts'
```

## Concept

The RWMutex is a unit which prevents parallel conflicting operations (which mutate same parts of an object. Basically, but not necessary, "write" operations), but allows parallel non-conflicting operations ("read" operations or "write" operations over independent parts of the object).

## Usage

```ts
import { RWMutex } from 'rw-mutex-ts';

const rwmutex = new RWMutex();

const user = {
  name: 'John',
  age: 20,
};

async function waitRandomTime() {
  await new Promise((res) => setTimeout(res, Math.floor(Math.random() * 1000)));
}

async function updateUser(name: string, age: number) {
  await rwmutex.lock();
  console.log(`Locked for write. Adjusting user: ${name} - ${age}`);
  await waitRandomTime();
  user.name = name;
  await waitRandomTime();
  user.age = age;
  console.log(`Write unlocked. Adjusted user: ${name} - ${age}`);
  rwmutex.unlock();
}

async function getUserInfo(tag: string) {
  await rwmutex.rLock();
  console.log(
    `locking for read. Getting user info (${tag}): ${user.name} - ${user.age}`
  );
  await waitRandomTime();
  console.log(
    `Read unlocked. Getting same user info (${tag}): ${user.name} - ${user.age}`
  );
  rwmutex.rUnlock();
}

// Run all in parallel. See what happens
updateUser('Anna', 20);
updateUser('John', 30);
getUserInfo('first try');
getUserInfo('second try');
updateUser('Alex', 40);
getUserInfo('third try');
```

Output:

```
Locked for write. Adjusting user: Anna - 20
Write unlocked. Adjusted user: Anna - 20
Locked for write. Adjusting user: John - 30
Write unlocked. Adjusted user: John - 30
locking for read. Getting user info (first try): John - 30
locking for read. Getting user info (second try): John - 30
Read unlocked. Getting same user info (second try): John - 30
Read unlocked. Getting same user info (first try): John - 30
Locked for write. Adjusting user: Alex - 40
Write unlocked. Adjusted user: Alex - 40
locking for read. Getting user info (third try): Alex - 40
Read unlocked. Getting same user info (third try): Alex - 40
```

If your opeartion can fail after getting a lock, use helper functions to ensure the unlock. Will you async function (or promise) either complete or fail, the mutex will still be unlocked:

```ts
await runWithMutexW(rwmutex, async () => {
  /**Some stuff which can fail */
});

await runWithMutexR(rwmutex, async () => {
  /**Some stuff which can fail */
});
```

---
_Source: https://npm.io/package/rw-mutex-ts · Machine-readable twin of the npm.io package page. Health data is recomputed on every publish._