How do you synchronize workers via Redis so that two workers do not process the same object simultaneously?

To synchronize workers via Redis and prevent simultaneous processing of the same object, a distributed locking mechanism can be used. One common approach is to use the SET command with the NX (set if not exists) and PX (set expiry time) options to create a lock.

Example in Go using the go-redis library:

import (
    "context"
    "time"
    "github.com/go-redis/redis/v8"
)

func acquireLock(ctx context.Context, rdb *redis.Client, key string, ttl time.Duration) (bool, error) {
    // Attempt to set the key with a unique value and expiry time
    ok, err := rdb.SetNX(ctx, key, "locked", ttl).Result()
    return ok, err
}

func releaseLock(ctx context.Context, rdb *redis.Client, key string) error {
    return rdb.Del(ctx, key).Err()
}

// In the worker:
ctx := context.Background()
lockKey := "lock:object_id"
lockTTL := 30 * time.Second

locked, err := acquireLock(ctx, rdb, lockKey, lockTTL)
if err != nil {
    // handle error
}
if !locked {
    // another worker is already processing the object
    return
}

// Process the object

// After processing, release the lock
_ = releaseLock(ctx, rdb, lockKey)

It is important that the lock's TTL is long enough to cover the processing time but not too long to avoid prolonged locking in case of worker failure. For more reliable solutions, the Redlock algorithm can be used.