Django多处理和put后的空队列

我正在尝试使用Django中的线程制作类似于“任务管理器”的东西，它将等待一些工作

import multiprocessing
from Queue import Queue


def task_maker(queue_obj):
    while True:
        try:
            print queue_obj.qsize() # << always print 0
            _data = queue_obj.get(timeout=10)
            if _data:
                _data['function'](*_data['args'], **_data['kwargs'])
        except Empty:
            pass
        except Exception as e:
            print e


tasks = Queue()
stream = multiprocessing.Process(target=task_maker, args=(tasks,))
stream.start()


def add_task(func=lambda: None, args=(), kwargs={}):
    try:
        tasks.put({
            'function': func,
            'args': args,
            'kwargs': kwargs
        })
        print tasks.qsize() # print a normal size 1,2,3,4...

    except Exception as e:
        print e

导入多处理
从队列导入队列
def任务生成器（队列对象）：
尽管如此：
尝试：
打印队列_obj.qsize（）#当前代码存在两个问题。1） 对于多进程（但不是线程），函数
qsize（）
是不可靠的——我建议不要使用它，因为它很混乱。2） 不能直接修改从队列中获取的对象

考虑两个过程，来回发送数据。一方不知道另一方是否修改了某些数据，因为数据是私有的。要进行通信，请使用
Queue.put（）
或使用
管道显式发送数据

生产者/消费者系统工作的一般方式是：1）工作被塞进队列2）工作区，等待工作。当作业出现时，它会将结果放在不同的队列中。3） 管理器或“beancounter”进程使用第二个队列的输出，并打印或以其他方式处理它

玩得开心

#!/usr/bin/env python

import logging, multiprocessing, sys


def myproc(arg):
    return arg*2

def worker(inqueue, outqueue):
    logger = multiprocessing.get_logger()
    logger.info('start')
    while True:
        job = inqueue.get()
        logger.info('got %s', job)
        outqueue.put( myproc(job) )

def beancounter(inqueue):
    while True:
        print 'done:', inqueue.get()

def main():
    logger = multiprocessing.log_to_stderr(
            level=logging.INFO,
    )
    logger.info('setup')

    data_queue = multiprocessing.Queue()
    out_queue = multiprocessing.Queue()

    for num in range(5):
        data_queue.put(num)

    worker_p = multiprocessing.Process(
        target=worker, args=(data_queue, out_queue), 
        name='worker',
    )
    worker_p.start()

    bean_p = multiprocessing.Process(
        target=beancounter, args=(out_queue,),
        name='beancounter',
        )
    bean_p.start()

    worker_p.join()
    bean_p.join()
    logger.info('done')


if __name__=='__main__':
    main()

我知道了。我不知道为什么，但当我尝试“线程”，它的工作

from Queue import Queue, Empty
import threading

MailLogger = logging.getLogger('mail')


class TaskMaker(threading.Thread):

    def __init__(self, que):
        threading.Thread.__init__(self)
        self.queue = que

    def run(self):
        while True:
            try:
                print "start", self.queue.qsize()
                _data = self.queue.get()
                if _data:
                    print "make"
                    _data['function'](*_data['args'], **_data['kwargs'])
            except Empty:
                pass
            except Exception as e:
                print e
                MailLogger.error(e)

tasks = Queue()
stream = TaskMaker(tasks)
stream.start()


def add_task(func=lambda: None, args=(), kwargs={}):
    global tasks
    try:
        tasks.put_nowait({
            'function': func,
            'args': args,
            'kwargs': kwargs
        })

    except Exception as e:
        print e
        MailLogger.error(e)

你有没有考虑过直接使用？它易于使用，成熟，与django配合良好。除非你有压倒性的理由重新发明轮子，否则它确实是最好的工具。对于多进程（但不是线程），qsize（）函数是不可靠的。使用
线程
时，队列在同一进程中可用，因此是可靠的。对于多个进程，如果一个进程检查大小，而另一个进程同时添加一个元素，事情可能会变得混乱。因此，
qsize
对于多处理是不可靠的。