Question

我刚刚在Python中编写了一个任务队列，其任务是限制一次运行的任务数量。这与Queue.Queue略有不同，因为它不限制队列中可以有多少项，而是限制一次可以取出多少项。它仍然使用无界Queue.Queue来完成它的工作，但它依赖于Semaphore来限制线程数：

from Queue import Queue
from threading import BoundedSemaphore, Lock, Thread


class TaskQueue(object):
    """
    Queues tasks to be run in separate threads and limits the number
    concurrently running tasks.

    """

    def __init__(self, limit):
        """Initializes a new instance of a TaskQueue."""
        self.__semaphore = BoundedSemaphore(limit)
        self.__queue = Queue()
        self.__cancelled = False
        self.__lock = Lock()

    def enqueue(self, callback):
        """Indicates that the given callback should be ran."""
        self.__queue.put(callback)

    def start(self):
        """Tells the task queue to start running the queued tasks."""
        thread = Thread(target=self.__process_items)
        thread.start()

    def stop(self):
        self.__cancel()
        # prevent blocking on a semaphore.acquire
        self.__semaphore.release()
        # prevent blocking on a Queue.get
        self.__queue.put(lambda: None)

    def __cancel(self):
        print 'canceling'
        with self.__lock:
            self.__cancelled = True

    def __process_items(self):
        while True:
            # see if the queue has been stopped before blocking on acquire
            if self.__is_canceled():
                break

            self.__semaphore.acquire()

            # see if the queue has been stopped before blocking on get
            if self.__is_canceled():
                break

            callback = self.__queue.get()

            # see if the queue has been stopped before running the task
            if self.__is_canceled():
                break

            def runTask():
                try:
                    callback()
                finally:
                    self.__semaphore.release()

            thread = Thread(target=runTask)
            thread.start()
            self.__queue.task_done()

    def __is_canceled(self):
        with self.__lock:
            return self.__cancelled

除非我明确停止任务队列，否则Python解释器将永远运行。这比我想象的要复杂得多。如果您查看stop方法，您会看到我在队列中设置canceled标志，release信号量和put无操作回调。最后两部分是必要的，因为代码可能会在Semaphore或Queue上阻止。我基本上必须强迫这些循环，以便循环有机会爆发。

此代码有效。在运行试图并行运行数千个任务的服务时，此类非常有用。为了保持机器平稳运行并防止操作系统尖叫太多活动线程，此代码将限制任何时候生活的线程数。

我之前在C＃中编写过类似的代码块。让那些代码特别干净的原因是.NET有一个叫做CancellationToken的东西，几乎每个线程类都使用它。只要有阻塞操作，该操作就会采用可选的令牌。如果父任务被取消，那么使用该令牌阻止的任何子任务也将立即被取消。这似乎是一种更清晰的退出方式，而不是通过释放信号量或将值放入队列来“伪造它”。

我想知道在Python中是否有相同的方法可以做到这一点？我绝对想要使用线程而不是异步事件。我想知道是否有办法使用两个Queue.Queue来实现同样的事情，其中一个具有最大尺寸而另一个没有 - 但我仍然不确定如何处理取消。

Answer 1

我认为使用中毒和Thread.join()可以简化您的代码：

from Queue import Queue
from threading import Thread

poison = object()

class TaskQueue(object):

    def __init__(self, limit):
        def process_items():
            while True:
                callback = self._queue.get()
                if callback is poison:
                    break
                try:
                    callback()
                except:
                    pass
                finally:
                    self._queue.task_done()
        self._workers = [Thread(target=process_items) for _ in range(limit)]
        self._queue = Queue()

    def enqueue(self, callback):
        self._queue.put(callback)

    def start(self):
        for worker in self._workers:
            worker.start()

    def stop(self):
        for worker in self._workers:
            self._queue.put(poison)
        while self._workers:
            self._workers.pop().join()

未测试。

为简洁起见，我删除了评论。

此外，在此版本中，process_items()确实是私有的。

BTW：Queue模块的重点是让你摆脱可怕的锁定和事件。

Answer 2

您似乎正在为队列中的每个任务创建新线程。这本身就是浪费，也会引发你如何限制线程数的问题。

相反，一种常见的方法是创建固定数量的工作线程，让它们自由地从队列中提取任务。要取消队列，您可以clear it让工作人员保持活力，以期将来的工作。

Answer 3

我接受了Janne Karila的建议并创建了一个线程池。这消除了对信号量的需求。问题是，如果您希望队列消失，您必须停止工作线程的运行（只是我之前所做的变化）。新代码非常相似：

class TaskQueue(object):
    """
    Queues tasks to be run in separate threads and limits the number
    concurrently running tasks.

    """

    def __init__(self, limit):
        """Initializes a new instance of a TaskQueue."""
        self.__workers = []
        for _ in range(limit):
            worker = Thread(target=self.__process_items)
            self.__workers.append(worker)
        self.__queue = Queue()
        self.__cancelled = False
        self.__lock = Lock()
        self.__event = Event()

    def enqueue(self, callback):
        """Indicates that the given callback should be ran."""
        self.__queue.put(callback)

    def start(self):
        """Tells the task queue to start running the queued tasks."""
        for worker in self.__workers:
            worker.start()

    def stop(self):
        """
        Stops the queue from processing anymore tasks. Any actively running
        tasks will run to completion.

        """
        self.__cancel()
        # prevent blocking on a Queue.get
        for _ in range(len(self.__workers)):
            self.__queue.put(lambda: None)
            self.__event.wait()

    def __cancel(self):
        with self.__lock:
            self.__queue.queue.clear()
            self.__cancelled = True

    def __process_items(self):
        while True:
            callback = self.__queue.get()

            # see if the queue has been stopped before running the task
            if self.__is_canceled():
                break

            try:
                callback()
            except:
                pass
            finally:
                self.__queue.task_done()
        self.__event.set()

    def __is_canceled(self):
        with self.__lock:
            return self.__cancelled

如果仔细观察，我必须做一些会计来杀死工人。我基本上等待Event和工人一样多次。我clear基础队列，以防止工人以任何其他方式被取消。我也在等待将每个虚假值抽入队列后等待，因此一次只能有一个工人取消。

我已经对此进行了一些测试，它似乎正在运行。消除对虚假价值的需求仍然是一件好事。

在Python线程中模拟取消令牌

3 个答案: