具体的demo

以下是一个使用看门狗为Redis分布式锁续约的Python demo：

import redis
import threading
import time

class RedisLock:
    def __init__(self, redis_conn, key, timeout=30):
        self.redis_conn = redis_conn
        self.key = key
        self.timeout = timeout
        self.watch_dog_thread = None
        self.locked = False

    def acquire(self):
        """
        获取分布式锁，如果获取成功，则启动看门狗续约
        """
        while not self.locked:
            # 尝试获取锁
            lock_value = time.time() + self.timeout + 1
            acquired = self.redis_conn.set(self.key, lock_value, nx=True, ex=self.timeout)
            if acquired:
                # 获取锁成功，启动看门狗续约
                self.locked = True
                self.watch_dog_thread = threading.Thread(target=self.watch_dog)
                self.watch_dog_thread.start()
            else:
                # 获取锁失败，等待一段时间后重试
                time.sleep(0.1)

    def release(self):
        """
        释放分布式锁，同时停止看门狗续约
        """
        if self.locked:
            self.locked = False
            self.redis_conn.delete(self.key)
            self.watch_dog_thread.join()

    def renew(self):
        """
        续约，更新锁的过期时间
        """
        if self.locked:
            lock_value = time.time() + self.timeout + 1
            self.redis_conn.set(self.key, lock_value, xx=True, ex=self.timeout)

    def watch_dog(self):
        """
        看门狗线程，定期续约
        """
        while self.locked:
            time.sleep(self.timeout // 2)
            self.renew()

if __name__ == '__main__':
    redis_conn = redis.Redis(host='localhost', port=6379, db=0, decode_responses=True)
    lock = RedisLock(redis_conn, 'my_lock')
    try:
        lock.acquire()
        print('获取分布式锁成功')
        time.sleep(10)
    finally:
        lock.release()
        print('释放分布式锁')

在这个demo中，我们定义了一个RedisLock类，其中包含了获取锁、释放锁、续约等方法。在获取锁的时候，如果获取成功，则会启动一个看门狗线程，在锁的过期时间内定期向Redis发送续约请求。在释放锁的时候，会停止看门狗线程。在程序运行过程中，我们创建了一个RedisLock对象，并使用该对象获取分布式锁，然后等待一段时间后释放锁。