业务场景描述：
- 多个业务节点（多台主机运行同一个业务代码），但是只有一个节点真正运行（运行节点），其他都处于等待（备选节点）
- 运行节点一旦异常（服务挂掉，宕机，误操作等），其他备选节点，立刻有一个继续运行
- 之前的运行节点，重启之后，变为备选节点，处于等待节点
- 实现多节点高可用
分布式锁具备的功能：
- 资源唯一表示
- 锁续时（锁绝对不能不设置过期时间）
- 锁误操作（改变了不属于自己的锁）-----资源唯一表示，即可解决
- Redis 挂掉（或者哨兵模式下，主节点挂掉，哨兵发现和选举延迟，或者redis整个服务挂掉），本地服务处理。
- redis连接挂掉之后重启，锁可能还在，也可能没有了。没有之后，可能其他的备选节点会加锁成功，成为运行节点
- 也就是说：Redis重启之后，之前的运行节点说不一定不是运行节点了。
- 非运行节点，需要把本地的服务都停掉，确保只有一个运行节点在运行主要业务逻辑
- 额外要求：锁具备高可用，易用，其他业务代码侵入小。所以使用修饰器。
实现步骤：
唯一资源表示：
- Redis中的key选取某一个服务名称，value选取主机（或本地IP）+ 主进程ID作为标示
代码：
def redis_distributed_lock(lock_name: str):
"""
redis分布式锁
:param lock_name: redis中锁的名称
:return:
"""
def redis_function(func):
def wrapper(self, *args, **kwargs):
"""
High-availability operating mechanism based on redis
:return: None
"""
redis_model = RedisModel()
lock_value = socket.gethostname() + "_" + str(threading.get_ident())
# 没有注册上,休息后再尝试注册
while True:
try:
result = redis_model.set_ex_nx(key=lock_name, value=lock_value, seconds=60)
# 执行主体方法
func(*args, **kwargs)
# 获取锁的过期时间
ttl = redis_model.ttl(key=lock_name)
time.sleep(ttl if ttl > 1 else 1)
except Exception as e:
self.logger.warning(
"Run redis_distributed_lock failed, cause: {}, traceback: {}".format(e, traceback.format_exc()))
time.sleep(5)
return wrapper
return redis_function
锁的续时间：
- 锁续时（锁绝对不能不设置过期时间）。
- 锁续时是个持续的操作（while True），尽量不能影响主体业务逻辑操作。我这里的处理是：续时操作，创建一个额外的线程（watch_dog）或者额外线程执行主体业务逻辑函数。
- 续时需要判断一下，Redis中的锁，还是否为本运行节点锁具有的锁。是的话，才进行续时，防止锁误操作。
- 不是的话，本地的服务可能需要都停掉，主进程处于备用状态，防止多节点运行。
- 1、要删除该运行节点下的所有创建的线程，并且不影响主进程继续运行，并处于备用状态，
- 2、如果子线程创建了进程，等等，需要将该节点下的所有进程也删除掉
代码：
修饰器：redis_distributed_lock
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
=================================================
@Project -> File
@IDE ：PyCharm
@Author ：Desmond.zhan
@Date ：2021/12/7 3:07 下午
@Desc ：redis分布式锁，运行执行leader节点的服务器运行，其他的阻塞，以达到高可用
通过注解方式，灵活性更强
==================================================
"""
import ctypes
import inspect
import multiprocessing
import socket
import threading
import time
import traceback
# 自定义Redis Model.
from xxxxxx import RedisModel
def _async_raise(tid, exctype):
"""raises the exception, performs cleanup if needed"""
tid = ctypes.c_long(tid)
if not inspect.isclass(exctype):
exctype = type(exctype)
res = ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, ctypes.py_object(exctype))
if res == 0:
raise ValueError("invalid thread id")
elif res != 1:
# """if it returns a number greater than one, you're in trouble,
# and you should call it again with exc=NULL to revert the effect"""
ctypes.pythonapi.PyThreadState_SetAsyncExc(tid, None)
raise SystemError("PyThreadState_SetAsyncExc failed")
def _async_stop_children_process():
"""
杀死主进程下所有的子进程
:return:
"""
children_process = multiprocessing.active_children()
for process in children_process:
process.terminate()
def redis_distributed_lock(lock_name: str):
"""
redis分布式锁
:param lock_name: redis中锁的名称
:return:
"""
def redis_function(func):
def wrapper(self, *args, **kwargs):
"""
High-availability operating mechanism based on redis
:return: None
"""
redis_model = RedisModel()
lock_value = socket.gethostname() + "_" + str(threading.get_ident())
# 没有注册上,休息后再尝试注册
while True:
try:
result = redis_model.set_ex_nx(key=lock_name, value=lock_value, seconds=60)
# 加锁成功后，判断是否该主机+线程用的这个锁,如果是，设置一个超时时间。否则仍旧等待加锁
self.logger.info("Redis set_nx result：{}".format(result))
self.logger.info(
"redis_model.get(lock_name) : {}, lock_value:{}".format(redis_model.get(lock_name), lock_value))
# 加锁成功
if result and redis_model.get(lock_name).decode(encoding="utf8") == lock_value:
# 获取到redis分布式锁，开启子线程，进行执行目标函数
t_func = threading.Thread(target=func, args=args, kwargs=kwargs)
t_func.start()
# 启动看门狗，lock续时
redis_model.lock_watchdog_timeout(key=lock_name, value=lock_value)
# 停止函数执行
_async_raise(tid=t_func.ident, exctype=SystemExit)
_async_stop_children_process()
# 获取锁的过期时间
ttl = redis_model.ttl(key=lock_name)
time.sleep(ttl if ttl > 1 else 1)
except Exception as e:
self.logger.warning(
"Run redis_distributed_lock failed, cause: {}, traceback: {}".format(e, traceback.format_exc()))
time.sleep(5)
return wrapper
return redis_function
续时操作：watch_dog
def lock_watchdog_timeout(self, key, value, seconds=30):
self.logger.info("key:{} lock watch dog threading start work ".format(self.get_key(key)))
try:
self._lock_extend(key, value, seconds)
except Exception as e:
self.logger.warning("redis lock lock_watchdog_timeout error, error info :{}".format(e))
def _lock_extend(self, key, value, lifetime):
while True:
try:
self.logger.debug("watch dog extend key time, key:{}".format(self.get_key(key)))
# 判断redis中还是否为本进程持有的锁
redis_value = self.redis_client.get(name=self.get_key(key))
if redis_value != value:
self.logger.warning(
"Watch dog warning, redis lock value is not acquired, will suspend function execution")
self.logger.warning("this value:{}, redis value".format(value, redis_value))
# watch dog也没意义了，直接返回吧
return
result = self.redis_client.expire(name=self.get_key(key), time=lifetime)
self.logger.debug("{} extend result : {}".format(self.get_key(key), str(result)))
time.sleep(lifetime // 2)
except Exception as e:
self.logger.warning(
"Run _lock_extend failed, cause: {}, traceback: {}".format(e, traceback.format_exc()))
time.sleep(5)
另外：
- 如果除主进程之外，其他的某些子进程，备选节点也需要保留，可以在
_async_stop_children_process()中根据进程名字，或者进程名字前缀，进行过滤，选择性删除子进程 - 如果是子线程创建子进程，子进程再创建进程，可以在
_async_stop_children_process()方法中迭代，发现所有的进程，杀死进程之后，这些子进程下的子线程也就不存在了。 - 由于主进程可能创建子线程，而成为备选节点后，主进程仍旧存活，子线程需要清除掉，所有不能使用signal去处理子进程，这里是调用底层C语言暴露的API，可见参考
参考：
https://docs.python.org/zh-cn/3.7/library/ctypes.html#module-ctypes
https://docs.python.org/zh-cn/3.6/c-api/init.html?highlight=pythreadstate_setasyncexc
https://docs.python.org/3/library/multiprocessing.html
https://docs.python.org/zh-cn/3/library/signal.html?highlight=signal
