azjezz / mutex

Mutex Locking for hack projects

Mutex

Hack implementation of reactphp-muxted by WyriHaximus.

---

Install

To install via Composer, use the command below :

composer require azjezz/mutex

About

This package provides two things:

• An interface for mutex locking
• A in-memory implementation of that interface

Example

use namespace AzJezz\Mutex;
use namespace HH\Asio;

require 'vendor/autoload.hack';

<<__EntryPoint>>
async function main(): Awaitable<void> {
  Facebook\AutoloadMap\initialize();

  $mutex = new Mutex\Memory();
  
  $jobs = vec[
    foo($mutex), // first to acquire the lock
    foo($mutex), // won't be able to acquire the lock
    foo($mutex), // same
  ];

  foreach($jobs as $job) {
    await $job;
  }
}

async function foo(
  Mutex\MutexInterface $mutex
): Awaitable<void> {
  $lock = await $mutex->acquire('foo');
  if ($lock is nonnull) {
    echo "doing things \n";
    await Asio\usleep(10000000);
    echo "finished my job, releasing the lock \n";
    await $mutex->release($lock);
    return;
  }

  echo "someone else have requested the 'foo' lock\n";
}

License

The Mutex Project is open-sourced software licensed under the MIT-licensed.

mutex's Issues

lock helper.

add AzJezz\Mutex\lock() helper functions.

stub :

function lock<T>((function(): T) $call): ?T;

usage example :

use function AzJezz\Mutex\lock;

function foo(): void {
  lock('foo-function', () ==> {
    // only one thread at a time may execute this statement
  });
}

this would require a new final abstract class MutexRepository to hold the mutex implementation to use with the lock helper.

stub :

final abstract class MutexRepository {
  public static function set(MutexInterface $mutex);

  /**
   * Implementation should throw an exception if the repository holds
   * no mutex implementations OR return a default implementation.
   *
   * if the implementation returned a default implementations, it should
   * call `set($default)` to ensure that the same instance is returned in the
   * next call.
   */
  public static function get(): MutexInterface;
}

Expiring Locks.

example :

$lock = await $mutex->acquire(
  'foo', 
  300, // Expiring time in seconds
);

do {

  // do things

  if (bar()) {
    $finished = false;
  } else {
    $finished = true;
  }

  if (!$finished  && $mutex->getRemainingLifetime($lock) <= 5) {
    invariant(!$mutex->isExpired($lock), 'Lock lost during the overall process');

    await $mutex->refresh($lock);
  }

} while(!$finished);