Struct DistributedLock

pub struct DistributedLock { /* private fields */ }

A distributed lock implementation using Redis SET NX EX pattern.

This lock is designed for distributed systems where multiple instances need to coordinate exclusive access to shared resources. It uses the Redis SET command with NX (only set if not exists) and EX (expiry time) options to atomically acquire locks.

Features

• Atomic acquisition: Uses Redis SET NX to ensure only one instance can acquire the lock
• Automatic expiry: Lock automatically expires after TTL to prevent deadlocks
• Unique identifiers: Each lock acquisition gets a unique ID to prevent accidental release by other instances
• Auto-release on drop: Lock is released when the guard is dropped (best-effort via spawned task)

TTL Considerations

The TTL should be set to accommodate the worst-case runtime of the protected operation. If the operation runs longer than TTL, another instance may acquire the lock concurrently. For long-running operations, consider:

• Setting a generous TTL (e.g., 2x expected runtime)
• Implementing lock refresh/extension during processing
• Breaking the operation into smaller locked sections

Example

// Key format: {prefix}:lock:{name}
let lock_key = format!("{}:lock:{}", prefix, "my-operation");
let lock = DistributedLock::new(redis_client, &lock_key, Duration::from_secs(60));
if let Some(guard) = lock.try_acquire().await? {
    // Do exclusive work here
    // Lock is automatically released when guard is dropped
}

Implementations

impl DistributedLock

pub fn new(pool: Arc<Pool>, lock_key: &str, ttl: Duration) -> Self

Creates a new distributed lock instance.

Arguments

• pool - Redis connection pool
• lock_key - Full Redis key for this lock (e.g., “myprefix:lock:cleanup”)
• ttl - Time-to-live for the lock. Lock will automatically expire after this duration to prevent deadlocks if the holder crashes.

pub async fn try_acquire(&self) -> Result<Option<LockGuard>>

Attempts to acquire the distributed lock.

This is a non-blocking operation. If the lock is already held by another instance, it returns Ok(None) immediately without waiting.

Returns

• Ok(Some(LockGuard)) - Lock was successfully acquired
• Ok(None) - Lock is already held by another instance
• Err(_) - Redis communication error

Lock Semantics

The lock is implemented using Redis SET key value NX EX ttl:

• NX: Only set if key does not exist (atomic check-and-set)
• EX: Set expiry time in seconds

Trait Implementations

impl Clone for DistributedLock

fn clone(&self) -> DistributedLock

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.