javascript based lockflag is a mutex like is a simple mutually exclusive flag or MuTex with internal auto acquire/release while setting value or alternatively use the acquire and release function manually.
ps: if you wish to use the acquire and release functions manually use the same setter functions with the last argument of auto with a false value.
if manager is the mutex function you are using like this manager.setValue(42)
please use the same function like this manager.setValue(42, false)
to use the acquire and release functions manually.
the last argument of all setter functions
(including setValue
, push
, removeAt
, shift
) has a variable argument called auto
set with a default true
, which allows the setter functions to be used directly safely assuming the acquire and release functions will be called automatically
.
method implementation with auto definition, auto default
is true
:
(method) setValue(auto?: boolean): Promise<any>
method implementation with valueTransformer with auto definition, auto default
is true
:
(method) setValue(valueTransformer?: (val: any) => any, auto?: boolean): Promise<any>
- value based mutex
- value based with invoke function mutex
- json single value mutex
- json single value with invoke function mutex
- json nested value mutex
- json nested value with invoke function mutex
- semaphore array queue
- semaphore array queue with invoke function mutex
const mutex = require("xmutex");
const manager = mutex.value();
"json": {
"invokeWith": mutex.json.nestedInvokeWith,
"nestedInvokeWith": mutex.json.nestedInvokeWith,
"nonNestedInvokeWith": mutex.json.nonNestedInvokeWith,
"nested": mutex.json.nested,
"nonNested": mutex.json.nonNested
},
"array": {
"queue": mutex.array.queue,
"invokeWith": mutex.array.invokeWith
},
"value": mutex.value
(async () => {
const manager = mutex.value.value();
console.log(await manager.getValue()); // null
await manager.setValue(42);
console.log(await manager.getValue()); // 42
})();
if manager is the mutex function you are using like this manager.setValue(42)
please use the same function like this manager.setValue(42, false)
to use the acquire and release functions manually.
// if you are using the manual acquire and release functions
// you may use the same functions with a auto flag
// as the last argument
(async () => {
const manager = mutex.value.value();
console.log(await manager.getValue()); // null
const release = await manager.acquire();
await manager.setValue(42, false);
await manager.setValue(41, false);
console.log(await manager.getValue()); // 41
release();
console.log(await manager.getValue()); // 41
try {
await manager.setValue(34, false);
} catch(e) {
console.log("ERROR LOG: ", e);
} finally {
console.log("\nThe was an demo or an example of acquire lock manually used");
}
})();
(async () => {
const valueManager = mutex.value.invokeWith();
// Set value with transformation (e.g., multiply by 2)
await valueManager.setValue(42, (val) => val * 2);
console.log(await valueManager.getValue()); // 84
// Set value without transformation
await valueManager.setValue(50);
console.log(await valueManager.getValue()); // 50
})();
(async () => {
const manager = mutex.json.nonNested();
console.log(await manager.getValue('key1')); // undefined
await manager.setValue('key1', 42);
await manager.setValue('key2', 'hello');
console.log(await manager.getValue('key1')); // 42
console.log(await manager.getValue('key2')); // hello
console.log(await manager.getAllValues()); // { key1: 42, key2: 'hello' }
})();
(async () => {
const manager = mutex.json.nonNestedInvokeWith();
console.log(await manager.getValue('key1')); // undefined
await manager.setValue('key1', 42, (val) => { console.log("set value with transformer function: ", val); return val; }); //
await manager.setValue('key2', 'hello', (val) => { console.log("set value with transformer function:", val); return val; }); //
console.log(await manager.getValue('key1')); // 42
console.log(await manager.getValue('key2')); // hello
console.log(await manager.getAllValues()); // { key1: 42, key2: 'hello' }
})();
(async () => {
const manager = mutex.json.nested();
console.log(await manager.getValue('key1')); // undefined
await manager.setValue('key1', 42); // Single level
await manager.setValue('key2.subkey1', 'hello'); // Nested level
await manager.setValue('key2.subkey2.subkey3', 'world'); // More deeply nested
await manager.setValue('key3.key1', 42); // Single level
await manager.setValue('key4', { "key1": 42 }); // Single level
console.log(await manager.getValue('key1')); // 42
console.log(await manager.getValue('key2.subkey1')); // hello
console.log(await manager.getValue('key2.subkey2.subkey3')); // world
console.log(await manager.getAllValues());
// Output:
// {
// key1: 42,
// key2: {
// subkey1: 'hello',
// subkey2: { subkey3: 'world' }
// }
// }
})();
(async () => {
const manager = mutex.json.invokeWith();
console.log(await manager.getValue('key1')); // undefined
// Setting a value and then invoking a transformer
await manager.setValue('key1', 42, (newValue) => {
console.log('Value set for key1:', newValue); // Output: Value set for key1: 42
});
console.log(await manager.getValue('key1')); // 42
// Setting a nested value and then invoking a transformer
await manager.setValue('key2.subkey1', 'hello', (newValue) => {
console.log('Value set for key2.subkey1:', newValue); // Output: Value set for key2.subkey1: hello
});
console.log(await manager.getValue('key2.subkey1')); // hello
// Check the entire object
console.log(await manager.getAllValues());
// Output:
// {
// key1: 42,
// key2: {z
// subkey1: 'hello'
// }
// }
})();
(async () => {
const arrayManager = mutex.array.queue();
// Push some values
await arrayManager.push(42);
await arrayManager.push('hello');
await arrayManager.push('world');
console.log(await arrayManager.getAllValues()); // [42, 'hello', 'world']
// Remove value at index 1
const removedValue = await arrayManager.removeAt(1);
console.log(removedValue); // 'hello'
console.log(await arrayManager.getAllValues()); // [42, 'world']
// Remove value at an out-of-bounds index
const invalidRemove = await arrayManager.removeAt(5);
console.log(invalidRemove); // undefined
console.log(await arrayManager.getAllValues()); // [42, 'world']
})();
(async () => {
const arrayManager = mutex.array.invokeWith();
// Set value with transformation (e.g., multiply by 2)
await arrayManager.setValue(0, 42, (val) => val * 2);
console.log(await arrayManager.getValue(0)); // 84
// Push value with transformation (e.g., append " world")
await arrayManager.push('hello', (val) => val + ' world');
console.log(await arrayManager.getAllValues()); // [ 84, 'hello world' ]
// Shift value with transformation (e.g., convert to uppercase)
const shiftedValue = await arrayManager.shift((val) => val.toString().toUpperCase());
console.log(shiftedValue); // "84"
// Remove value with transformation (e.g., reverse the string)
const removedValue = await arrayManager.removeAt(0, (val) => val.split('').reverse().join(''));
console.log(removedValue); // "dlrow olleh"
console.log(await arrayManager.getAllValues()); // []
})();
- include key or flag to be specified key and not just a function acquire/release lock