How to optimize performance under high load (1000 RPS) on a booking method with a mutex?

Under high load (1000 RPS), using a mutex for synchronizing the booking method can become a bottleneck, as the mutex serializes access and causes blocking. To optimize performance, you can:

• Minimize the lock scope: hold the mutex only for the critical section.
• Use finer-grained locking: for example, lock only specific resources or records related to booking.
• Apply lock-free data structures or atomic operations, if possible.
• Use channels to organize request queues, which can avoid blocking.
• Implement data sharding so that different goroutines work with different parts of the data without overlaps.
• Cache results or pre-reserve resources to reduce the number of lock acquisitions.

Example of minimizing lock scope:

var mu sync.Mutex

func Book(resourceID string) error {
    // Prepare data without locking

    mu.Lock()
    defer mu.Unlock()

    // Critical section: check and update booking status
    if isBooked(resourceID) {
        return errors.New("already booked")
    }
    markBooked(resourceID)

    return nil
}

If possible, consider architectural changes, such as using a message queue for asynchronous booking processing.