我希望能够加入（）Queue类，但如果调用尚未返回，则在一段时间后超时。最好的方法是什么？是否可以通过使用metaclass子类化子类来做到这一点？

import json
from multiprocessing import Process

def get_ticket(i):
    with open(''ticket'', ''r'') as f:    # 此时的读取信息时异步的, 可能出现进程1打开的时候进程2已经把票数修改了
        last_ticket_info = json.load(f)
    last_ticket = last_ticket_info[''count'']
    if last_ticket > 0:
        last_ticket = last_ticket - 1
        last_ticket_info[''count''] = last_ticket
        with open(''ticket'', ''w'') as f:    # 涉及到文件修改的地方现在还是异步的
            json.dump(last_ticket_info, f)
        print(''恭喜%s号用户,抢票成功!'' % i)
    else:
        print(''%s号用户,票已经抢光啦~'' % i)

if __name__ == ''__main__'':
    for i in range(1, 11):
        p = Process(target=get_ticket, args=(i,))
        p.start()

# 这样可能会出现全都抢到票的情况, 因为票数0还没来得及写入文件

# test文件

{"count": 0}   # 一会儿要用json, 只能用双引号

from multiprocessing import Process, Event

e = Event()  # 创建一个事件
print(e.is_set())  # 查看事件状态, bool, 初始状态 False

e.set()  # 将e事件的状态改为True
print(''在这里等待'')
e.clear()   # 将e事件的状态改为False
print(''等待中...'')
e.wait()     # 只有e时间状态为True时, 才能继续往下执行
print(''你好啊,我叫赛利亚'')

Queue([maxsize]) 创建共享的进程队列。
参数 ：maxsize是队列中允许的最大项数。如果省略此参数，则无大小限制。
底层队列使用管道和锁实现。

from multiprocessing import Process, Queue
# 专门设置线程间进行通信的
# 先进先出

q = Queue(3)  # 队列长度3, 可以放3条 数据

q.put(1)
q.put(2)
q.put(3)
# q.put(4)  # 超出队列长度,阻塞住啦  此处可以使用 q.put_nowait(4),此种情况下, 队列满了不会阻塞, 但是会报错, 可以抛异常和异常处理.
print(''队列是否满了>>>'', q.full())  # 判断队列是否满了

print(q.get())  # 取出1
print(q.get())  # 取出2
print(q.get())  # 取出3
print(''队列是否为空:'', q.empty())
# print(q.get())  # 此时队列为空, 阻塞住

q.put(4) ####################################
print(''又放了个数据进来'')
print(''队列是空吗?'', q.empty())

# while 1:  # 加了循环就可以等着队列有新增的时候拿东西
try:
    print(q.get(False))  # get的默认参数是True,如果队列空了取不到就阻塞住,改为False就不会阻塞,但是会报错
    # q.get_nowait()  # 和get(False)一个效果
except:     # 异常处理
    print(''队列目前是空的'')

# 队列在多线程中的应用

import time
from multiprocessing import Process, Queue

def girl(q):
    print(''来自男孩的消息'', q.get())
    print(''学校广播'', q.get())

def boy(q):
    q.put(''你好啊,女孩'')

if __name__ == ''__main__'':
    q = Queue(5)
    b = Process(target=boy, args=(q,))
    g = Process(target=girl, args=(q,))
    b.start()
    g.start()
    time.sleep(0.1)
    q.put(''好好学习'')

# 版本1  有bug
import time
from multiprocessing import Process, Queue

def producer(q):
    for i in range(1, 11):
        time.sleep(0.5)
        print(''生产了包子%s号'' % i)
        q.put(i)

def consumer(q):
    while 1:
        time.sleep(0.8)
        try:
            s = q.get(False)  # 不加False的话等队列中的包子都吃完了会阻塞住
            print(''顾客吃了包子%s号'' % s)
        except:
            print(''包子店关门了'')
            break
# 注意,如果此时顾客吃的比店铺生产的快, 就会先触发break, 所以此版本有缺陷 

if __name__ == ''__main__'':
    # 通过队列来摸底缓冲区, 设置缓冲区大小20
    q = Queue(20)
    pro_p = Process(target=producer, args=(q,))
    pro_p.start()
    con_p = Process(target=consumer, args=(q,))
    con_p.start()

# 版本2子进程发送结束信号  消费者吃得快
import time
from multiprocessing import Process, Queue

def producer(q):
    for i in range(1, 11):
        time.sleep(1)
        print(''生产了包子%s号'' % i)
        q.put(i)
    q.put(None)  # 给消费者发送一个结束信号

def consumer(q):
    while 1:
        s = q.get()
        if s == None:
            print(''包子店关门了'')
            break
        else:
            time.sleep(0.6)
            print(''顾客吃了包子%s号'' % s)

# 注意,如果此时顾客吃的比店铺生产的快, 就会先触发break, 所以此版本有缺陷

if __name__ == ''__main__'':
    # 通过队列来摸底缓冲区, 设置缓冲区大小20
    q = Queue(20)
    pro_p = Process(target=producer, args=(q,))
    pro_p.start()
    con_p = Process(target=consumer, args=(q,))
    con_p.start()

# 通过joinableQueue结束消费者子进程

import time
from multiprocessing import Process, Queue, JoinableQueue

def prodecer(q):
    for i in range(1, 11):
        time.sleep(1)
        print(''生产了包子%s号'' % i)
        q.put(i)
    #  记录了往队列中放了多少个和取出了多少个(收到了多少个task_done))
    q.join()
    # 等待接收全部task_done信号(共10个), 接收后才继续
    print(''客人都走了,关门中...'')

def consumer(q):
    while 1:
        time.sleep(2)
        s = q.get()
        print(''消费者吃了包子%s号'' % s)
        q.task_done()  # 每从队列中获取一个包子就发送一个task_done信号给生产者

if __name__ == ''__main__'':
    q = JoinableQueue(20)
    pro_p = Process(target=prodecer, args=(q,))
    pro_p.start()
    con_p = Process(target=consumer, args=(q,))
    con_p.daemon = True     # 把消费者子进程设置为守护进程,当主进程结束, 消费者子进程也结束   如果不设置守护进程, 消费者进程就会在while循环中的q.get()阻塞住,队列中已经没有包子了 
    con_p.start()

    pro_p.join()   # 等待生产者子进程结束, 主进程才结束
    print(''主进程结束'')

#JoinableQueue([maxsize])：这就像是一个Queue对象，但队列允许项目的使用者通知生成者项目已经被成功处理。通知进程是使用共享的信号和条件变量来实现的。

   #参数介绍：
    maxsize是队列中允许最大项数，省略则无大小限制。    
　 #方法介绍：
    JoinableQueue的实例p除了与Queue对象相同的方法之外还具有：
    q.task_done()：使用者使用此方法发出信号，表示q.get()的返回项目已经被处理。如果调用此方法的次数大于从队列中删除项目的数量，将引发ValueError异常
    q.join():生产者调用此方法进行阻塞，直到队列中所有的项目均被处理。阻塞将持续到队列中的每个项目均调用q.task_done（）方法为止，也就是队列中的数据全部被get拿走了。

 div {
 background:#aaa;
 width:18px;
 height:18px;
 position:absolute;
 top:10px;
 }　

 $(“#block1″).animate({left:”+=100″},function() {
 $(“#block2″).animate({left:”+=100″},function() {
 $(“#block1″).animate({left:”+=100″},function() {
 $(“#block2″).animate({left:”+=100″},function() {
 $(“#block1″).animate({left:”+=100″},function(){
 alert(“动画结束”);
 });
 });
 });
 });
 });

var FUNC=[
 function() {$("#block1").animate({left:"+=100"},aniCB);},
 function() {$("#block2").animate({left:"+=100"},aniCB);},
 function() {$("#block1").animate({left:"+=100"},aniCB);},
 function() {$("#block2").animate({left:"+=100"},aniCB);},
 function() {$("#block1").animate({left:"+=100"},aniCB);},
 function(){alert("动画结束")}
 ];
 var aniCB=function() {
 $(document).dequeue(“myAnimation”);
 }
 $(document).queue(“myAnimation”,FUNC);
 aniCB();　　

 //清空队列
 $(document).queue(“myAnimation”,[]);
 //加一个新的函数放在最后
 $(document).queue(“myAnimation”,function(){alert(“动画真的结束了！”)});

我有一个简单的任务，例如：

def worker(queue):
    while True:
        try:
            _ = queue.get_nowait()
        except Queue.Empty:
            break

if __name__ == '__main__':
    manager = multiprocessing.Manager()
    # queue = multiprocessing.Queue()
    queue = manager.Queue()

    for i in range(5):
        queue.put(i)

    processes = []

    for i in range(2):
        proc = multiprocessing.Process(target=worker,args=(queue,))
        processes.append(proc)
        proc.start()

    for proc in processes:
        proc.join()

看来multiprocessing.Queue可以完成我需要的所有工作，但另一方面，我看到了很多manager（）。Queue（）的示例，并且无法理解我的真正需求。看起来Manager（）。Queue（）使用某种代理对象，但我不明白这些目的，因为multiprocessing.Queue（）在没有任何代理对象的情况下执行相同的工作。

因此，我的问题是：

1）multiprocessing.Queue和multiprocessing.manager（）。Queue（）返回的对象之间的真正区别是什么？

2）我需要使用什么？