Python 3活动线程的限制计数（完成的线程不会退出）

Question

我想限制活动线程的数量。 我所看到的是，完成的线程会保持活动状态，并且不会退出自身，因此活动线程的数量一直在增长，直到出现错误为止。

以下代码一次仅启动8个线程，但是即使它们完成了，它们也仍然有效。 因此，这个数字一直在增长：

class ThreadEx(threading.Thread):
    __thread_limiter = None
    __max_threads = 2

    @classmethod
    def max_threads(cls, thread_max):
        ThreadEx.__max_threads = thread_max
        ThreadEx.__thread_limiter = threading.BoundedSemaphore(value=ThreadEx.__max_threads)

    def __init__(self, target=None, args:tuple=()):
        super().__init__(target=target, args=args)
        if not ThreadEx.__thread_limiter:
            ThreadEx.__thread_limiter = threading.BoundedSemaphore(value=ThreadEx.__max_threads)

    def run(self):
        ThreadEx.__thread_limiter.acquire()
        try:
            #success = self._target(*self._args)
            #if success: return True
            super().run()
        except:
            pass
        finally:
            ThreadEx.__thread_limiter.release()


def call_me(test1, test2):
    print(test1 + test2)
    time.sleep(1)


ThreadEx.max_threads(8)

for i in range(0, 99):
    t = ThreadEx(target=call_me, args=("Thread count: ", str(threading.active_count())))
    t.start()

由于for循环，线程数一直增加到99。我知道一个线程已经完成了工作，因为call_me已执行，并且threading.active_count（）已打印。

有人知道我如何确保已完成的线程无法存活？

Answer 1

这可能是一个愚蠢的答案，但对我来说，您似乎正在尝试重新发明ThreadPool 。

from multiprocessing.pool import ThreadPool
from time import sleep

p = ThreadPool(8)

def call_me(test1):
    print(test1)
    sleep(1)

for i in range(0, 99):
    p.apply_async(call_me, args=(i,))

p.close()
p.join()

这样可以确保在任何时间只有8个并发线程正在运行您的函数。 而且，如果您想提高性能，可以从多处理中导入Pool并使用它。 接口完全相同，但是您的池现在将成为子进程而不是线程，这通常会提高性能，因为GIL不会妨碍您。

Answer 2

我在汉奴的帮助下改变了班级。

我将其发布以供参考，也许对这篇文章中的其他人有用：

import threading
from multiprocessing.pool import ThreadPool
import time

    class MultiThread():
    __thread_pool = None

    @classmethod
    def begin(cls, max_threads):
        MultiThread.__thread_pool = ThreadPool(max_threads)

    @classmethod
    def end(cls):
        MultiThread.__thread_pool.close()
        MultiThread.__thread_pool.join()

    def __init__(self, target=None, args:tuple=()):
        self.__target = target
        self.__args = args

    def run(self):
        try:
            result = MultiThread.__thread_pool.apply_async(self.__target, args=self.__args)
            return result.get()
        except:
            pass


def call_me(test1, test2):
    print(test1 + test2)
    time.sleep(1)
    return 0


MultiThread.begin(8)
for i in range(0, 99):
    t = MultiThread(target=call_me, args=("Thread count: ", str(threading.active_count())))
    t.run()
MultiThread.end()

在方法begin确定的任何给定时间，线程的最大数量为8。 如果方法运行返回了某些内容，它还会返回所传递函数的结果。

希望能有所帮助。