DistributedLock

DistributedLock: A Comprehensive Overview

DistributedLock is a high-quality .NET library designed to provide strong and user-friendly distributed locking mechanisms. It primarily focuses on mutexes, reader-writer locks, and semaphores and supports multiple platforms and technologies. This versatility makes it an indispensable tool for developers who need to manage access to shared resources across various applications and machines.

Implementations

DistributedLock offers several implementations tailored to different underlying technologies. These implementations can be installed separately or together via the DistributedLock NuGet package, a convenient "meta" package that includes all available implementations. Each implementation is independently versioned, adhering to the Semantic Versioning (SemVer) model. Here’s a look at the diverse implementations available:

• DistributedLock.SqlServer: Utilizes Microsoft SQL Server for its locking mechanisms.
• DistributedLock.Postgres: Employs PostgreSQL for distributed locks.
• DistributedLock.MySql: Supports MySQL and MariaDB systems.
• DistributedLock.Oracle: Integrates with Oracle databases for locking.
• DistributedLock.Redis: Takes advantage of Redis to manage distributed locks.
• DistributedLock.Azure: Leverages Azure blobs for lock management.
• DistributedLock.ZooKeeper: Uses Apache ZooKeeper to provide distributed locking capabilities.
• DistributedLock.FileSystem: Utilizes file locks for synchronization.
• DistributedLock.WaitHandles: Applies operating system global WaitHandles for locking, specifically for Windows.

Each specific package name links to documentation tailored for that particular implementation, ensuring detailed and relevant information is readily accessible.

Synchronization Primitives

DistributedLock provides several types of synchronization primitives:

• Locks: These offer exclusive access to a specific region of code, ensuring only one entity can execute the section at any given point in time.
• Reader-Writer Locks: These facilitate concurrent data reading by multiple entities while ensuring that only one entity can write at a time, maintaining data integrity.
• Semaphores: Similar to locks, semaphores can permit multiple entities (up to a specified number) to access a section concurrently, instead of just one.

While all implementations include support for locks, not all extend this support to reader-writer locks or semaphores. Referencing the specific documentation for each implementation is recommended for more information.

Basic Usage

Names

In distributed systems, synchronization primitives are identified by a name provided through their constructor. DistributedLock simplifies name management by handling formatting constraints specific to the underlying technologies.

Acquire

The basic method for accessing these primitives involves the Acquire method, which returns a handle representing the lock hold. This handle is disposed of to release the lock, making management straightforward:

var myDistributedLock = new SqlDistributedLock("lockName", connectionString);
using (myDistributedLock.Acquire())
{
    // lock is held here
}

TryAcquire

An alternative approach is TryAcquire, which immediately attempts to acquire a lock and returns null if unsuccessful:

using (var handle = myDistributedLock.TryAcquire())
{
    if (handle != null)
    {
        // lock acquired successfully
    }
    else
    {
        // lock not acquired
    }
}

Async Support and Timeouts

DistributedLock supports async versions of these methods, suitable for asynchronous programming in C#. Timeouts are also configurable, allowing developers to define how long the system should wait to acquire a lock before giving up.

Cancellation

With an optional CancellationToken parameter, DistributedLock provides the ability to interrupt lock acquisition if necessary, adding a layer of flexibility and robustness.

Providers

For those utilizing dependency injection, DistributedLock’s provider system effectively separates lock naming from other configuration details, such as connection strings. This setup fits well within the structure of ASP.NET Core applications or similar frameworks.

Contributing and Community

DistributedLock is an open-source project supported by its community. Contributions and involvement are encouraged and facilitated through clear documentation outlining how to get started with the repository, ensuring new contributors are well-supported.

Conclusion

In essence, DistributedLock stands out as a versatile and easy-to-use library for managing distributed locks across various systems. It simplifies the complexity of synchronization in distributed environments, making it a valuable tool for developers seeking to enhance the reliability and performance of their applications.