在横向扩展情况下，如何让重复作业仅在一个实例上触发

import redis
import time

class DistributedLock:
    def __init__(self, redis_client, lock_key, expire_time=10):
        self.redis_client = redis_client
        self.lock_key = lock_key
        self.expire_time = expire_time
        self.identifier = str(uuid.uuid4())

    def acquire(self):
        while True:
            if self.redis_client.setnx(self.lock_key, self.identifier):
                self.redis_client.expire(self.lock_key, self.expire_time)
                return True
            time.sleep(0.1)

    def release(self):
        with self.redis_client.pipeline() as pipe:
            while True:
                try:
                    pipe.watch(self.lock_key)
                    if pipe.get(self.lock_key) == self.identifier:
                        pipe.multi()
                        pipe.delete(self.lock_key)
                        pipe.execute()
                        return True
                    pipe.unwatch()
                    break
                except redis.WatchError:
                    continue
        return False

# 示例使用
redis_client = redis.StrictRedis(host='localhost', port=6379, db=0)
lock = DistributedLock(redis_client, 'my_lock_key')

if lock.acquire():
    try:
        # 执行重复作业
        print("Executing task...")
    finally:
        lock.release()
else:
    print("Task is already being executed by another instance.")