Concurrent Operation Protection

Patterns and techniques for preventing race conditions and ensuring data consistency during concurrent operations, particularly in data import and synchronization systems.

Lock Implementation Patterns

Database-Backed Locking

Using database records as distributed locks that survive application restarts:

// Acquire lock pattern
const acquired = await prisma.syncStatus.updateMany({
  where: { 
    lockedAt: null,  // Only update if not locked
    OR: [
      { lockedAt: { lt: expiredThreshold } }  // Or expired lock
    ]
  },
  data: { 
    lockedAt: new Date(),
    lockedBy: processId 
  }
})

if (acquired.count === 0) {
  throw new Error("Operation already in progress")
}

Lock Safety Features

• Expiration timeout: Automatic lock release after timeout (e.g., 10 minutes)
• Process identification: Track which process holds the lock
• Graceful cleanup: Explicit lock release in finally blocks
• Failure recovery: Handle crashed processes that don't release locks

Critical Section Protection

Import/Sync Operations

Protecting data integrity during batch operations:

• Single-threaded processing: Ensure only one import/sync runs at a time
• Transaction boundaries: Group related operations in database transactions
• Rollback capabilities: Undo partial operations on failure
• Progress tracking: Monitor operation status for debugging

Global State Management

Protecting shared resources like caches and mappings:

• Cache invalidation: Coordinate cache updates across concurrent requests
• Memory state: Ensure single-threaded access to mutable global state
• Resource cleanup: Proper resource management in multi-threaded contexts

Implementation Strategies

Database Table Approach

Using existing tables for lock state:

-- Add locking fields to status table
ALTER TABLE SyncStatus ADD COLUMN lockedAt TIMESTAMP NULL;
ALTER TABLE SyncStatus ADD COLUMN lockedBy VARCHAR(255) NULL;

Benefits:

• Survives application restarts and crashes
• Visible in database for debugging
• Atomic operations through database constraints
• Easy to implement with existing ORM tools

Lock Lifecycle Management

1. Pre-operation: Attempt to acquire lock with timeout
2. Operation execution: Perform the protected work
3. Progress updates: Optional status updates during long operations
4. Cleanup: Always release lock in finally block
5. Error handling: Log lock failures for monitoring

Common Concurrency Scenarios

User-Triggered Duplicates

Preventing double-clicks and rapid button presses:

• UI button disabling during operation
• Server-side duplicate detection
• Idempotency keys for critical operations
• User feedback during processing

Automated vs Manual Operations

Coordinating scheduled jobs with user-initiated actions:

• Shared locking mechanism across all operation types
• Priority systems for critical vs routine operations
• Queue-based processing for high-volume scenarios
• Clear error messages when operations conflict

Data Source Coordination

Managing multiple data input sources:

• Lock across all import types (file uploads, API syncs, manual entry)
• Consistent data validation across sources
• Audit trails for debugging conflicts
• Recovery procedures for partial failures

Error Handling and Monitoring

Lock Failure Response

• Clear user messaging: Explain when operations are blocked
• Retry mechanisms: Automatic or manual retry options
• Progress visibility: Show status of blocking operations
• Administrative override: Emergency lock release capabilities

Operational Monitoring

• Lock duration tracking: Identify operations taking too long
• Failure rate monitoring: Detect system issues
• Deadlock detection: Identify circular dependencies
• Performance impact: Measure overhead of locking mechanisms

See also

• Data Pipeline Architecture
• Enterprise System Reliability
• Database Transaction Management