Python子线程异常捕获 & Python自定义优化线程池

前言

虽然CPython因为GIL的存在导致多线程的并发计算能力大打折扣,但是在i/o密集型的场景时,使用多线程还是能带来效率上的飞跃。近期在使用多线程时遇到了主线程无法捕获子线程抛出的异常问题,这里记录一下解决的办法。

需求
将某一指定目录下所有的文件(包含子目录下的文件)中所有被$[]$字符包裹起来的变量替换成指定的值,这是一个典型的io密集的场景,因此考虑使用多线程提升效率

原demo

def main():
      conf_map = {'DB_HOST': "X.X.X.X",'DB_USER': "root",'DB_PASSWD': 'abcd1234'}
      conf_files=['/etc/abc/', '/var/abc']
      thpool = ThreadPoolExecutor(5)
      for file in conf_files:
          thpool.submit(replace_config, file, conf_map)
      thpool.shutdown(wait=True)

def replace_config(file, conf_map, tmp_conf_path):
    with open(file, 'r') as f:
        content = f.read()

    # 需替换的变量的样式为: $[PASSWORD]$
    wrapper_pattern = re.compile('\$\[([\w-]+)\]\$')
    var_list = wrapper_pattern.findall(content)

    for var in var_list:
        try:
            value = conf_map[var]
            wrapper = "$[%s]$" % var
            content = content.replace(wrapper, value)
        except KeyError:
            print('key error')
            os.system("mv {} /tmp".format(tmp_conf_path))
            raise Exception('[%s]文件中存在未知的key: %s' % (file, var))

    with open(file, 'w') as f:
        f.write(content)    

demo内直接使用python3.2版本以后引入的ThreadPoolExecutor库使用多线程,在子线程无异常时是正常运行的,但是在子线程出现异常时(比如子线程的内部逻辑里发现了不存在key时, except KeyError会捕获到异常),但是你会发现子线程异常终止了,主线程但是却没有异常抛出。

经过一番搜索,在python官方手册中了解到了原因:
在这里插入图片描述

参考官方文档链接:
https://docs.python.org/zh-cn/3/library/_thread.html

原因即为:

使用start()方法启动子线程时,解释器会为子线程开辟独立的栈空间,主线程自然就无法获取子线程栈的信息。当线程异常中止时,会自行退出而不会将此异常raise到主线程。那么得知了原因,就可以找到解决的办法了。思路是继承标准库的Thread类,进行一些小的改写封装。

修改后的demo

class ReplaceThread(Thread):
    def __init__(self, file, conf_map):
        super(ReplaceThread, self).__init__()
        self.file = file
        self.conf_map = conf_map

        self.exitcode = 0
        self.exception = None

    def run(self):
        try:
            self._run()
        except Exception as e:
            # 如果捕获到异常,返回值改为不等于0
            self.exitcode = 1
            self.exception = e

    def _run(self):
        with open(self.file, 'r') as f:
            content = f.read()

        # 需替换的变量的样式为: $[PASSWORD]$
        wrapper_pattern = re.compile('\$\[([\w-]+)\]\$')
        var_list = wrapper_pattern.findall(content)

        for var in var_list:
            try:
                value = self.conf_map[var]
                wrapper = "$[%s]$" % var
                content = content.replace(wrapper, value)
            except KeyError:
                raise Exception('[%s]文件中存在未知的key: %s‘ % (self.file, var))

        with open(self.file, 'w') as f:
            f.write(content)
            
# 主线程无法直接捕获子线程内的异常,因此自定义了Thread类,在子线程内定义其出现异常时的返回值,在主线程内根据返回值
# 来判断是否出现异常,并进行下一步操作
 def main():
    conf_files=['/etc/abc/', '/var/abc']
    conf_map = {'DB_HOST': "X.X.X.X",'DB_USER': "root",'DB_PASSWD': 'abcd1234'}
    t_objs = []
    for file in conf_files:
        t = ReplaceThread(file=file, conf_map=conf_map)
        t.start()
        t_objs.append(t)
	
    for t in t_objs:
        t.join()
        if t.exitcode != 0:
            os.system("mv {} /tmp".format(tmp_conf_path))
            raise Exception(t.exception)  

如此这般,在主线程里通过自定义的子线程返回值来判断子线程是否有异常,如果子线程有异常则主线程接替抛出子线程里的异常。这里另外还要注意,子线程的join()操作要放到start()操作全部完成了之后再进行,避免主线程被子线程阻塞,这样就变成了串行执行多线程就失去了意义了。

问题
这里是以迭代对象来循环启动多线程的,假设迭代对象数量很长,那就会启动成百上千个线程,这是不愿意看到的,为了避免这种情况,可自定义线程池,仅需对上方demo中的main()方法再做一点小改动即可。

实现

 def main():
    conf_files=['/etc/abc/', '/var/abc']
    conf_map = {'DB_HOST': "X.X.X.X",'DB_USER': "root",'DB_PASSWD': 'abcd1234'}
    
    # 实现的方法是对迭代的对象进行截取,每次只截取前10个对象,执行完这10个对象的操作后再截取随后后的10个对象,直到迭代对象为空。
    n = 0
    pool_size = 10
    files = conf_files
    file_num = len(files)
    while files:
        t_objs = []
        start_index = n * pool_size
        end_index = (n + 1) * pool_size

        for i in range(pool_size):
            current_index = start_index + i
            if current_index < file_num:
                file = self.conf_files[current_index]
                t = ReplaceThread(file=file, conf_map=conf_map)
                t.start()
                t_objs.append(t)

        for t in t_objs:
            t.join()
            if t.exitcode != 0:
                os.system("rm -rf {}".format(base_conf_path))
                raise Exception(t.exception)

        n += 1
        files = conf_files[end_index:]

复杂度优化:
上方的方法是对迭代的对象列表进行切片,每次只截取前10个对象,执行完这10个对象的操作后再截取随后后的10个对象,直到迭代对象为空。这种方式使用list的切片,时间复杂度为O(k),k为截取长度。

有没有更好的方式?这里列举一种复杂度更低的方式:

 def main():
    conf_files=['/etc/abc/', '/var/abc']
    conf_map = {'DB_HOST': "X.X.X.X",'DB_USER': "root",'DB_PASSWD': 'abcd1234'}
    
    pool_size = 10
    files = self.conf_files
    file_num = len(files)
    while files:
        if file_num < pool_size:
            pool_size = file_num

        t_objs = []
        for i in range(pool_size):
            file = files.pop()
            t = ReplaceThread(file=file, conf_map=conf_map)
            t.start()
            t_objs.append(t)

        for t in t_objs:
            t.join()
            if t.exitcode != 0:
                os.system("rm -rf {}".format(tmp_conf_path))
                raise Exception(t.exception)

        file_num -= pool_size

说明:

利用了顺序表(list)的 尾部操作/获取长度操作 时间复杂度均为O(1)的特性,每次操作list的尾部元素,这个方式的复杂度更低

总结

子线程异常处理问题由此就得以解决,通过一些小改动也可以实现自定义的低复杂度线程池。重要的事情只说一遍:遇到问题查官方文档

参与评论 您还未登录,请先 登录 后发表或查看评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:技术黑板 设计师:CSDN官方博客 返回首页

打赏作者

ywq935

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值