Options
All
  • Public
  • Public/Protected
  • All
Menu

Class SharedLock

Shared mutex wrapper for the safe read lock.

The module SharedLock is a collection of general purpose functions wrapping shared mutex for ensuring the safe lock. If you lock a mutex (with your business logic code) through any function of the SharedLock module, the shared mutex would be automatically unlocked after your business, even if an error has been occured in your business.

author

Jeongho Nam - https://github.com/samchon

Hierarchy

  • SharedLock

Index

Type aliases

Static Closure

Closure: () => void | Promise<void>

Type of closure function defining your business logic.

Type declaration

    • (): void | Promise<void>
    • Returns void | Promise<void>

Methods

Static lock

  • lock<Mutex>(mutex: Mutex, closure: Closure): Promise<void>
  • Read locks a shared mutex with your business.

    Shares a mutex until be the closure has been completed. If there're someone who have already monopolied the mutex, the function call would be blocked until all of them to return their acquisitions.

    When succeeded to share the mutex, the lock function will call the closure, a custom function defning your business. After the closure function be returned, the lock function automatically unlocks the mutex, even if the closure function throws any error.

    Therefore, when using this lock function, you don't need to consider about returning the lock acquistion after your business. It would just be done automatically.

    throw

    Exception would be thrown if the closure function throws any error.

    Type parameters

    Parameters

    • mutex: Mutex

      Target shared mutex to read lock.

    • closure: Closure

      A function defining your business.

    Returns Promise<void>

Static try_lock

  • try_lock<Mutex>(mutex: Mutex, closure: Closure): Promise<boolean>
  • Tries to read lock a shared mutex with your business.

    Attemps to share a mutex without blocking. If succeeded to share the mutex immediately, it returns true directly. Otherwise there's someone who has already monopolied the mutex, the function gives up the trial immediately and returns false directly without calling the closure.

    When succeeded to share the mutex, the try_lock function will call the closure, a custom function defning your business. After the closure function be returned, the try_lock function automatically unlocks the mutex, even if the closure function throws any error.

    Therefore, when using this try_lock function, you don't need to consider about returning the lock acquistion after your business. It would just be done automatically.

    throw

    Exception would be thrown if the closure function throws any error.

    Type parameters

    Parameters

    • mutex: Mutex

      Target shared mutex to try read lock.

    • closure: Closure

      A function defining your business.

    Returns Promise<boolean>

    Whether succeeded to share the mutex or not.

Static try_lock_for

  • try_lock_for<Mutex>(mutex: Mutex, ms: number, closure: Closure): Promise<boolean>
  • Tries to read lock a shared mutex with your business until timeout.

    Attemps to share a mutex until timeout. If succeeded to share the mutex until timeout, it returns true after calling the closure. Otherwise failed to acquiring the shared lock in the given time, the function gives up the trial and returns false without calling the closure.

    Failed to acquring the shared lock in the given time (returns false), it means that there's someone who has already monopolied the mutex and does not return it over the timeout.

    When succeeded to share the mutex, the try_lock_for function will call the closure, a custom function defning your business. After the closure function be returned, the try_lock function automatically unlocks the mutex, even if the closure function throws any error.

    Therefore, when using this try_lock_for function, you don't need to consider about returning the lock acquistion after your business. It would just be done automatically.

    throw

    Exception would be thrown if the closure function throws any error.

    Type parameters

    Parameters

    • mutex: Mutex

      Target mutex to try lock until timeout.

    • ms: number

      The maximum miliseconds for waiting.

    • closure: Closure

      A function defining your business.

    Returns Promise<boolean>

    Whether succeeded to share the mutex or not.

Static try_lock_until

  • try_lock_until<Mutex>(mutex: Mutex, at: Date, closure: Closure): Promise<boolean>
  • Tries to read lock a shared mutex with your business until time expiration.

    Attemps to share a mutex until time expiration. If succeeded to share the mutex until the time expiration, it returns true after calling the closure. Otherwise failed to acquiring the shared lock in the given time, the function gives up the trial and returns false without calling the closure.

    Failed to acquring the shared lock in the given time (returns false), it means that there's someone who has already monopolied the mutex and does not return it over the time expiration.

    When succeeded to share the mutex, the try_lock_until function will call the closure, a custom function defning your business. After the closure function be returned, the try_lock function automatically unlocks the mutex, even if the closure function throws any error.

    Therefore, when using this try_lock_until function, you don't need to consider about returning the lock acquistion after your business. It would just be done automatically.

    throw

    Exception would be thrown if the closure function throws any error.

    Type parameters

    Parameters

    • mutex: Mutex

      Target mutex to try lock until time expiration.

    • at: Date

      The maximum time point to wait.

    • closure: Closure

      A function defining your business.

    Returns Promise<boolean>

    Whether succeeded to share the mutex or not.

Generated using TypeDoc