如何在Python中多次调用线程？

如果这是个愚蠢的问题，我很抱歉。我正在尝试使用多线程类来完成不同的任务，这涉及到在不同的时间多次调用这些多线程。但我不确定该用哪种方法。代码如下所示：

class workers1(Thread):  
    def __init__(self):  
        Thread.__init__(self)  
    def run(self):  
        do some stuff  

class workers2(Thread):  
    def __init__(self):  
        Thread.__init__(self)  
    def run(self):  
        do some stuff  

class workers3(Thread):  
    def __init__(self):  
        Thread.__init__(self)  
    def run(self):
        do some stuff  

WorkerList1=[workers1(i) for i in range(X)]  
WorkerList2=[workers2(i) for i in range(XX)]  
WorkerList2=[workers3(i) for i in range(XXX)]  


while True:  
    for thread in WorkerList1:  
         thread.run (start? join? or?)
    for thread in WorkerList2:  
          thread.run (start? join? or?)  
    for thread in WorkerList3:  
          thread.run (start? join? or?)  
    do sth  .

我试图让所有WorkerList中的所有线程同时开始工作，或者至少在同一时间左右开始工作。当它们全部终止后，我想再次调用所有线程

如果没有循环，我可以使用；但由于我只能开始一次线程，开始显然不适合这里。如果我使用run，似乎所有线程都是按顺序启动的，不仅是同一列表中的线程，还包括来自不同列表的线程

---

有人能帮忙吗？

这里有很多误解：

• 只能启动线程的特定实例一次。但是在您的例子中，for循环在线程的不同实例上循环，每个实例都被分配给循环中的变量

  thread

  ，因此在每个线程上调用

  start（）

  方法完全没有问题。（您可以将其视为变量

  thread

  是列表中实例化的

  thread（）

  对象的别名）

• run（）

  与

  join（）

  不同：调用

  run（）

  的执行过程就像是按顺序编程一样。

  run（）

  方法不会启动新线程，它只是执行方法中的语句，就像执行任何其他函数调用一样

• join（）。为了使
  join（）
  在线程中正常工作，必须首先在此线程上调用
  start（）
  

---

此外，您应该注意，一旦线程完成执行，就不能重新启动线程：必须重新创建线程对象，才能再次启动它。一种解决方法是在

run（）

方法的末尾调用

线程。但是，我不建议这样做，因为这将禁止使用
join（）
方法来检测线程的执行结束。
如果在循环中调用
thread.start（）
，实际上每个线程只启动一次，因为列表中的所有条目都是不同的线程对象（它们属于同一个类并不重要）。您不应该直接调用线程的
run（）
方法——它应该由
start（）调用
方法。直接调用它不会在单独的线程中调用它。
我也遇到了同样的难题，并提出了这个对我来说非常有效的解决方案。它还允许高效地使用线程终止装饰程序

关键功能是使用线程刷新器，该线程刷新器在
main
中被实例化和
.start
ed。该线程刷新线程将运行一个函数，该函数实例化和启动所有其他线程（实际线程、任务执行线程）线程。使用线程杀手装饰线程刷新功能，可以在满足特定条件（如
main
终止）时杀死所有线程

@ThreadKiller(arg) #qu'est-ce que c'est
def RefreshThreads():
    threadTask1 = threading.Thread(name = "Task1", target = Task1, args = (anyArguments))
    threadTask2 = threading.Thread(name = "Task2", target = Task2, args = (anyArguments))
    threadTask1.start()
    threadTask2.start()

#Main
while True:
    #do stuff
    threadRefreshThreads = threading.Thread(name = "RefreshThreads", target = RefreshThreads, args = ())
    threadRefreshThreads.start()

下面的代码创建了一个类，该类只是一个线程，但它是启动线程，并再次调用thread类的初始化，以便线程不知道它已被调用

从线程导入线程
类MTThread（线程）：
def _uuinit_uuu（self，name=”“，target=None）：
self.mt_name=名称
self.mt_target=目标
线程。初始化（self，name=name，target=target）
def启动（自）：
super（）.start（）
线程。初始化（self，name=self.mt\u name，target=self.mt\u target）
def运行（自）：
super（）.run（）
线程。初始化（self，name=self.mt\u name，target=self.mt\u target）
定义代码（）：
#一些代码
thread=MTThread（name=“SomeThread”，target=code）
thread.start（）
thread.start（）
但我正在使用start（）命令方法在循环中，我的程序实际上可能会给我一个运行时错误，表示线程已经启动。因此，我无法在每个线程中再次调用run方法。如果我的线程已经启动并完成执行，我如何再次调用嵌入在线程中的run方法？我的重点是在eac中调用run方法h线程多次每个线程的
run（）
方法只调用一次。在
run（）
中编写一个循环，或者使用模块使用一些生产者-消费者模式。定义数组时，第二个WorkerList2不应该是WorkerList3吗？您可以更详细地解释一下（在您的问题中）为什么以及如何解决这个问题？“试试这个”对未来的读者没有帮助
from threading import Thread
from time import sleep
def runA():
    while a==1:
        print('A\n')
        sleep(0.5)

if __name__ == "__main__":
    a=1
    t1 = Thread(target = runA)
    t1.setDaemon(True)
    t1.start()
    sleep(2)
    a=0
    print(" now def runA stops")
    sleep(3)
    print("and now def runA continue")
    a=1
    t1 = Thread(target = runA)
    t1.start()
    sleep(2)