RedLock.net Documentation

The Redlock algorithm is designed for independent Redis instances. However, RedLock.net supports replicated master/slave sets by treating each RedLockEndPoint as a single unit.

To use replicated instances, provide a RedLockEndPoint where the EndPoints property contains the list of servers in that replication set.

Risks of using replication:

• Write operations: All Redlock operations (Lock, Extend, Unlock) are writes and must be performed on the master. If a master fails and a slave is not automatically promoted, the instance becomes unusable.
• Race conditions: If a master fails after acquiring a lock but before propagating it to slaves, a newly promoted master might not have the lock, potentially allowing another process to acquire it simultaneously.
• Stale locks: If a master fails after releasing a lock but before propagation, the lock may persist in the slaves until the original expiry time is reached.

// Example: Using multiple independent replicated sets
var redlockEndPoints = new List<RedLockEndPoint>
{
	new RedLockEndPoint
	{
		EndPoints = 
		{
			new DnsEndPoint("replicatedset1-server1", 6379),
			new DnsEndPoint("replicatedset1-server2", 6379),
			new DnsEndPoint("replicatedset1-server3", 6379)
		}
	},
	new RedLockEndPoint
	{
		EndPoints = 
		{
			new DnsEndPoint("replicatedset2-server1", 6379),
			new DnsEndPoint("replicatedset2-server2", 6379),
			new DnsEndPoint("replicatedset2-server3", 6379)
		}
	},
	new RedLockEndPoint
	{
		EndPoint = new DnsEndPoint("independent-server", 6379)
	}
};

var redlockFactory = RedLockFactory.Create(redlockEndPoints);

The RedLockFactory is the central object used to manage distributed locks. You should create it once during application startup, reuse it throughout your application, and dispose of it when the application shuts down.

You can initialize it in two ways:

1. Automatic Connection Management: Pass a list of RedLockEndPoint objects. RedLock will manage its own StackExchange.Redis connections.
2. Existing Connections: Pass a list of RedLockMultiplexer objects. This allows you to reuse existing ConnectionMultiplexer instances.

// Option 1: RedLock maintains its own connections
var endPoints = new List<RedLockEndPoint>
{
	new DnsEndPoint("redis1", 6379),
	new DnsEndPoint("redis2", 6379),
	new DnsEndPoint("redis3", 6379)
};
var redlockFactory = RedLockFactory.Create(endPoints);

// Option 2: Use existing StackExchange.Redis connections
var existingConnectionMultiplexer1 = ConnectionMultiplexer.Connect("redis1:6379");
var existingConnectionMultiplexer2 = ConnectionMultiplexer.Connect("redis2:6379");
var existingConnectionMultiplexer3 = ConnectionMultiplexer.Connect("redis3:6379");

var multiplexers = new List<RedLockMultiplexer>
{
	existingConnectionMultiplexer1,
	existingConnectionMultiplexer2,
	existingConnectionMultiplexer3
};
var redlockFactory = RedLockFactory.Create(multiplexers);

If you want the application to wait for a lock to become available instead of giving up immediately, use the overload of CreateLockAsync that accepts wait and retry parameters.

• wait: The total amount of time to block and retry before giving up.
• retry: The interval between retry attempts.
• CancellationToken: You can pass a token to cancel the blocking wait.

var resource = "the-thing-we-are-locking-on";
var expiry = TimeSpan.FromSeconds(30);
var wait = TimeSpan.FromSeconds(10);
var retry = TimeSpan.FromSeconds(1);

// Blocks until acquired or 'wait' timeout is reached
await using (var redLock = await redlockFactory.CreateLockAsync(resource, expiry, wait, retry))
{
	if (redLock.IsAcquired)
	{
		// Do stuff
	}
}

var resource = "the-thing-we-are-locking-on";
var expiry = TimeSpan.FromSeconds(30);
var wait = TimeSpan.FromSeconds(10);
var retry = TimeSpan.FromSeconds(1);

// blocks until acquired or 'wait' timeout
await using (var redLock = await redlockFactory.CreateLockAsync(resource, expiry, wait, retry)) // there are also non async Create() methods
{
	// make sure we got the lock
	if (redLock.IsAcquired)
	{
		// do stuff
	}
}
// the lock is automatically released at the end of the using block