我正在尝试为 Python 3.4 中的一个项目制作线程飞行软件，其中我需要线程自行重新启动，以防在传感器读取期间发生 I/O 错误或类似的意外崩溃。因此，我正在努力制作一个看门狗来检查线程是否已死亡并重新启动它们。

起初，我尝试检查线程是否不再活动并重新启动它，这样做是这样的：

>>> if not a_thread.isAlive():
...     a_thread.start()
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
  File "c:\Python34\lib\threading.py", line 847, in start
    raise RuntimeError("threads can only be started once")
RuntimeError: threads can only be started once

从以下角度来看，这种行为是有道理的threading和 Python 本身，但这让我的工作变得更加困难。因此，我实现了一个解决方案，使用字典来存储初始线程并将其复制到新对象并在必要时启动它。不幸的是这也不起作用。 这是一个基本示例：

import threading
import logging
import queue
import time
from copy import copy, deepcopy

def a():
    print("I'm thread a")
def b():
    print("I'm thread b")

# Create thread objects
thread_dict = {
'a': threading.Thread(target=a, name='a'),
'b': threading.Thread(target=b, name='b')
}

threads = [copy(t) for t in thread_dict.values()]

for t in threads:
    t.start()
for i in range(len(threads)):
    if not threads[i].isAlive():
        temp = thread_dict[threads[i].name]
        threads[i] = deepcopy(temp)
        threads[i].start()
    thread(i).join(5)

返回：

I'm thread a
I'm thread b
Traceback (most recent call last):
  File "main_test.py", line 25, in <module>
    threads[i] = deepcopy(temp)
  File "c:\Python34\lib\copy.py", line 182, in deepcopy
    y = _reconstruct(x, rv, 1, memo)
  ... (there's about 20 lines of traceback within copy)
  File "c:\Python34\lib\copyreg.py", line 88, in __newobj__
    return cls.__new__(cls, *args)
TypeError: object.__new__(_thread.lock) is not safe, use _thread.lock.__new__()

所以显然threading对象复制不安全...是否有办法重新启动线程而不重新创建整个对象？

没有理由让你的线程死掉。

如果它们真的崩溃了，你的整个程序也会崩溃。

如果他们只是引发异常，您只需捕获异常即可。

如果他们正常返回，你就可以不这样做。

您甚至可以简单地包装线程函数以在异常或返回时重新启动自身：

def threadwrap(threadfunc):
    def wrapper():
        while True:
            try:
                threadfunc()
            except BaseException as e:
                print('{!r}; restarting thread'.format(e))
            else:
                print('exited normally, bad thread; restarting')
    return wrapper

thread_dict = {
    'a': threading.Thread(target=wrapper(a), name='a'),
    'b': threading.Thread(target=wrapper(b), name='b')
}    

问题解决了。

您无法重新启动线程。

大多数平台都没有办法这样做。

从概念上讲，它没有任何意义。当一个线程结束时，它的堆栈就死了；其父级被标记或发出信号；一旦它加入，它的资源就会被销毁（包括内核级资源，如进程表条目）。重新启动它的唯一方法是创建一套全新的一切。您已经可以通过创建新线程来做到这一点。

所以，就这么做吧。如果您确实不想在内部处理异常，只需存储构造参数并使用它们来启动新线程即可。

您甚至可以创建自己的子类来为您挂载它们：

class RestartableThread(threading.Thread):
    def __init__(self, *args, **kwargs):
        self._args, self._kwargs = args, kwargs
        super().__init__(*args, **kwargs)
    def clone(self):
        return RestartableThread(*self._args, **self._kwargs)

现在很容易“复制”线程（使用您想要的语义）：

if not a_thread.is_alive():
    a_thread = a_thread.clone()

Yes, threading.Thread对象复制不安全

您期望发生什么？最好的情况是，你会在同一个操作系统级线程对象周围得到一个不同的包装器，这样你就可以欺骗Python，让它没有注意到你正在尝试做一些非法的、可能引发段错误的事情，而它试图阻止你这样做。正在做。