理解Queue队列中join()与task_done()的关系

最近在写多线程爬虫，遇到一个场景，爬虫需要一个入口url然后爬取更多的url。为了线程安全，我使用了queue队列。这里我把问题归纳为生产者消费者问题，多线程爬虫就是多个消费者，生成者负责把爬虫爬取的新的url放到队列中。

在这个过程中，生产者要一直关注消费者新产出的url，然后放到队列中供消费者使用（这么看起来这个生产者有点黑），所以这里要用一个死循环，让生产者一直关注新的url产生情况。
多个消费者同样也要一直关注队列，一旦有新的url产生，就买买买！！！所以这里也需要一个死循环。

那么问题来了，我们的市场是有限的（一个网站的url是有限的，总会被爬完），当所有的url被爬完后，我们的生产者和消费者还在死循环中，那么什么时候才能结束这两个死循环呢？

这个时候我们就要站的更高一点来看了，这个生产者消费者模型中，我们还能看到组织这次活动的主线程，主线程组织了这场活动，看到生产者和消费者们参加了活动就撒手不管了直接回家了。这样主线程就太悠闲了，我们可以在活动未完成之前阻塞主线程，不让他走，让他监控整个活动现场，一旦发现活动结束了就让他收场子了，这样生产者消费者就可以被迫下班，结束死循环。

task_done()、join()
task_done()：每当消费者get()一次，无论消费者是否从队列中获取到东西，都会产生一个任务。当消费者完成这个任务后需要调用task_done()来告诉队列这个任务已经完成了。

这个任务是相对于队列queue来说的，而调用queue的就是主线程，所以我们可以理解为是主线程发布的任务

join()：join()函数放到的地方后面的代码就会被阻塞，直到队列中所有的元素都被接收和处理完毕才会执行后面的代码。就是队列中既没有任务也没有元素时，就会取消阻塞。

关系：如果线程里每从队列里get()一次，但没有执行task_done()，则join无法判断队列到底有没有结束，在最后执行join()是等不到结果的，会一直挂起。
————————————————
 

在网上大多关于join()与task_done()的结束原话是这样的：

Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号

Queue.join() 实际上意味着等到队列为空，再执行别的操作

但是可能很多人还是不太理解，这里以我自己的理解来阐述这两者的关联。

理解

如果线程里每从队列里取一次，但没有执行task_done()，则join无法判断队列到底有没有结束，在最后执行个join()是等不到结果的，会一直挂起。

可以理解为，每task_done一次 就从队列里删掉一个元素，这样在最后join的时候根据队列长度是否为零来判断队列是否结束，从而执行主线程。

下面看个自己写的例子：

下面这个例子，会在join()的地方无限挂起，因为join在等队列清空，但是由于没有task_done，它认为队列还没有清空，还在一直等。

import threading
import queue
from time import sleep


# 之所以为什么要用线程，因为线程可以start后继续执行后面的主线程，可以put数据，如果不是线程直接在get阻塞。
class Mythread(threading.Thread):
    def __init__(self, que):
        threading.Thread.__init__(self)
        self.queue = que

    def run(self):
        while True:
            sleep(1)
            if self.queue.empty():
                # 判断放到get前面，这样可以，否则队列最后一个取完后就空了，直接break，走不到print
                break

            item = self.queue.get()
            print(item, '...')
            self.queue.task_done()
            """
            如果把self.queue.task_done()  注释去掉，就会顺利执行完主程序。
            这就是“Queue.task_done()函数向任务已经完成的队列发送一个信号”这句话的意义，能够让join()函数能判断出队列还剩多少，是否清空了。
            """

        return


myque = queue.Queue()
tasks = [Mythread(myque) for x in range(2)]  # 2个线程
# print(tasks)
for x in range(10):
    myque.put(x)  # 快速生产

for x in tasks:
    t = Mythread(myque)  # 把同一个队列传入2个线程
    t.start()

myque.join()

print("---finish---")

如果把self.queue.task_done()  注释去掉，就会顺利执行完主程序。

这就是“Queue.task_done()函数向任务已经完成的队列发送一个信号”这句话的意义，能够让join()函数能判断出队列还剩多少，是否清空了。

而事实上我们看下queue的源码可以看出确实是执行一次未完成队列减一：

 def task_done(self):
 '''Indicate that a formerly enqueued task is complete.

 Used by Queue consumer threads. For each get() used to fetch a task,
 a subsequent call to task_done() tells the queue that the processing
 on the task is complete.

 If a join() is currently blocking, it will resume when all items
 have been processed (meaning that a task_done() call was received
 for every item that had been put() into the queue).

 Raises a ValueError if called more times than there were items
 placed in the queue.
 '''
 with self.all_tasks_done:
 unfinished = self.unfinished_tasks - 1
 if unfinished <= 0:
 if unfinished < 0:
 raise ValueError('task_done() called too many times')
 self.all_tasks_done.notify_all()
 self.unfinished_tasks = unfinished

快速生产-慢速消费

上面的演示代码是快速生产-慢速消费的场景，我们可以直接用task_done()与join()配合，来让empty()判断出队列是否已经结束。 当然，queue我们可以正确判断是否已经清空，但是线程里的get队列是不知道，如果没有东西告诉它，队列空了，因此get还会继续阻塞，那么我们就需要在get程序中加一个判断，如果empty()成立，break退出循环，否则get()还是会一直阻塞。

慢速生产-快速消费

但是如果生产者速度与消费者速度相当，或者生产速度小于消费速度，则靠task_done()来实现队列减一则不靠谱，队列会时常处于供不应求的状态，常为empty，所以用empty来判断则不靠谱。 那么这种情况会导致 join可以判断出队列结束了，但是线程里不能依靠empty()来判断线程是否可以结束。 我们可以在消费队列的每个线程最后塞入一个特定的“标记”，在消费的时候判断，如果get到了这么一个“标记”，则可以判定队列结束了，因为生产队列都结束了，也不会再新增了。 代码如下：

import threading
import queue
from time import sleep


# 之所以为什么要用线程，因为线程可以start后继续执行后面的主线程，可以put数据，如果不是线程直接在get阻塞。
class Mythread(threading.Thread):
    def __init__(self, que):
        threading.Thread.__init__(self)
        self.queue = que

    def run(self):
        while True:
            item = self.queue.get()
            self.queue.task_done()
            """
             #这里要放到判断前，否则取最后最后一个的时候已经为空，直接break，task_done执行不了，join()判断队列一直没结束
            """
            if item == None:
                break
            print(item, '...')

        return


myque = queue.Queue()
tasks = [Mythread(myque) for x in range(2)]  # 2个线程
# print(tasks)

for x in tasks:
    t = Mythread(myque)  # 把同一个队列传入2个线程
    t.start()

for x in range(10): # 慢速生产
    sleep(2)
    myque.put(x)

for x in tasks: # 快速消费
    myque.put(None)  # 结束标志

myque.join()

print("---finish---")

注意点：

put队列完成的时候千万不能用task_done()，否则会报错：

task_done() called too many times

因为该方法仅仅表示get成功后，执行的一个标记。

参考:

理解Queue队列中join()与task_done()的关系 | 漏洞人生https://www.vuln.cn/8610Queue队列中join()与task_done()的作用_jelly-CSDN博客0x00 前言最近在写多线程爬虫，遇到一个场景，爬虫需要一个入口url然后爬取更多的url。为了线程安全，我使用了queue队列。这里我把问题归纳为生产者消费者问题，多线程爬虫就是多个消费者，生成者负责把爬虫爬取的新的url放到队列中。在这个过程中，生产者要一直关注消费者新产出的url，然后放到队列中供消费者使用（这么看起来这个生产者有点黑），所以这里要用一个死循环，让生产者一直关注新的url产生情况。多个消费者同样也要一直关注队列，一旦有新的url产生，就买买买！！！所以这里也需要一个死循环。那么https://blog.csdn.net/xy_sunny/article/details/115210693