Question

我有一个GUI应用程序，需要从中获取和解析各种资源 GUI主循环旁边的网络。我使用python多处理模块搜索了选项，因为这些 fetch操作不仅包含阻塞IO，还包含大量解析，因此多处理可能比python线程更好。使用Twisted会很容易，但这次Twisted不是一个选项。

我在这里找到了一个简单的解决方案：

Python subprocess: callback when cmd exits

问题是回调中没有调用回调 MainThread。

所以我想出了以下解决方案：

delegate.py

import os
import multiprocessing as mp
import signal
from collections import namedtuple
import uuid
import logging


_CALLBACKS = {}
_QUEUE = mp.Queue()

info = logging.getLogger(__name__).info


class Call(namedtuple('Call', 'id finished result error')):

    def attach(self, func):
        if not self.finished:
            _CALLBACKS.setdefault(self.id, []).append(func)
        else:
            func(self.result or self.error)

        return self

    def callback(self):
        assert self.finished, 'Call not finished yet'
        r = self.result or self.error
        for func in _CALLBACKS.pop(self.id, []):
            func(r)

    def done(self, result=None, error=None):
        assert not self.finished, 'Call already finished'
        return self._replace(finished=(-1 if error else 1),
            result=result, error=error)

    @classmethod
    def create(clss):
        call = clss(uuid.uuid4().hex, 0, None, None) # uuid ???
        return call

def run(q, cb, func, args=None, kwargs=None):
    info('run: try running %s' % func)
    try:
        cb = cb.done(result=func(*(args or ()), **(kwargs or {})))
    except Exception, err:
        cb = cb.done(error=err)
    q.put(cb)
    os.kill(os.getppid(), signal.SIGUSR2) # SIGUSR2 ???
    info('run: leaving')

def on_callback(sig, frame):
    info('on_callback: checking queue ...')
    c = _QUEUE.get(True, 2)
    info('on_callback: got call - %s' % repr(c))
    c.callback()

signal.signal(signal.SIGUSR2, on_callback) # SIGUSR2 ???

def delegate(func, *args, **kwargs):
    info('delegate: %s %s' % (func, args,))
    cb = Call.create()
    mp.Process(target=run, args=(_QUEUE, cb, func, args, kwargs,)).start()
    return cb


__all__ = ['delegate']

使用

from delegate import delegate

def sleeper(secs):
    assert secs >= 1, 'I need my Augenpflege'
    info('sleeper: will go to sleep for %s secs' % secs)
    sleep(secs)
    info('sleeper: woke up - returning result')
    return ['sleeper', 'result']

def on_sleeper_result(r):
    if isinstance(r, Exception):
        info('on_sleeper_result: got error: %s' % r)
    else:
        info('on_sleeper_result: got result: %s' % r)

from delegate import delegate
delegate(sleeper, 3).attach(on_sleeper_result)
delegate(sleeper, -3).attach(on_sleeper_result)
while 1:
    info('main: loop')
    sleep(1)

输出

0122 08432 MainThread INFO  delegate: <function sleeper at 0x163e320> (3,)
0123 08432 MainThread INFO  delegate: <function sleeper at 0x163e320> (-3,)
0124 08437 MainThread INFO  run: try running <function sleeper at 0x163e320>
0124 08437 MainThread INFO  sleeper: will go to sleep for 3 secs
0124 08432 MainThread INFO  main: loop
0125 08438 MainThread INFO  run: try running <function sleeper at 0x163e320>
0126 08438 MainThread INFO  run: leaving
0126 08432 MainThread INFO  on_callback: checking queue ...
0126 08432 MainThread INFO  on_callback: got call - Call(id='057649cba7d840e3825aa5ac73248f78', finished=-1, result=None, error=AssertionError('I need my Augenpflege',))
0127 08432 MainThread INFO  on_sleeper_result: got error: I need my Augenpflege
0127 08432 MainThread INFO  main: loop
1128 08432 MainThread INFO  main: loop
2129 08432 MainThread INFO  main: loop
3127 08437 MainThread INFO  sleeper: woke up - returning result
3128 08437 MainThread INFO  run: leaving
3128 08432 MainThread INFO  on_callback: checking queue ...
3129 08432 MainThread INFO  on_callback: got call - Call(id='041420c6c83a489aa5c7409c662d4917', finished=1, result=['sleeper', 'result'], error=None)
3129 08432 MainThread INFO  on_sleeper_result: got result: ['sleeper', 'result']
3129 08432 MainThread INFO  main: loop
4130 08432 MainThread INFO  main: loop
5132 08432 MainThread INFO  main: loop
...

到目前为止，这种方法效果很好，但我的多处理经验模块是适中的，我有点不确定这是否会没有效果。我的问题是 - 使用时我应该特别注意的是什么以这种方式进行多处理......或者是否有'更正确'的模式使用python标准库的异步回调机制？

Answer 1

您没有理由在主循环中使用信号（低级api）进行python多处理和忙等待。

你必须在QThread中运行你的（修改过的）事件循环，它可以直接调用qt代码，或者使用QApplication.postEvent（或pyqtSignal）在主线程中执行它

# this should be in the delegate module
while 1:
    c = _QUEUE.get(True) # no timeout
    c.callback() # or post event to main thread

您还可以查看this page，了解qt

中线程之间的通信

Answer 2

您的代码有效，但并不是那么简单。让我们逐步完成代码。

这会在主进程中创建一个Call实例：

def delegate(func, *args, **kwargs):
    cb = Call.create()

但是当您将cb传递给工作进程时，

mp.Process(target=run, args=(_QUEUE, cb, func, args, kwargs,)).start()

在Call期间复制os.fork实例，从而创建第二个单独的实例。然后呢调用cb.done以及调用返回第三个cb._replace实例的Call：

def done(self, result=None, error=None):
    assert not self.finished, 'Call already finished'
    return self._replace(finished=(-1 if error else 1),
        result=result, error=error)

以上调用私有的namedtuple方法_replace。它可能是一个简单的Python语句，如

self.finished = -1 if error else 1

如果Call是object的子类而不是namedtuple的子类。子类化namedtuple在__init__中保存了一些输入，但由于我们需要修改namedtuple的属性，因此后来变得非常笨拙......

同时，主进程中Call返回的原始delegate(...)实例调用attach：

delegate(...).attach(on_sleeper_result)

这会修改全局_CALLBACKS字典。工作进程无法在_CALLBACKS中了解此更改;在工作进程中_CALLBACKS仍然是空的dict。因此，您必须通过Call将工作人员mp.Queue实例传回主要流程，cb.id使用_CALLBACKS引用Call中的正确功能。

所有这一切都有效，但是每次调用delegate都会创建三个Call个实例，并且代码可能误导未经认识的三个mp.Pool.apply_async实例都是同一个对象....一切顺利，但它有点复杂。

您是否考虑过使用callback的{{1}}参数？

import multiprocessing as mp
import logging
import time
import collections

_CALLBACKS=collections.defaultdict(list)

logger=mp.log_to_stderr(logging.DEBUG)

def attach(name,func):
    _CALLBACKS[name].append(func)

def delegate(func, *args, **kwargs):
    id=kwargs.pop('id')
    try:
        result=func(*args,**kwargs)
    except Exception, err:
        result=err
    return (id,result)

def sleeper(secs):
    assert secs >= 1, 'I need my Augenpflege'
    logger.info('sleeper: will go to sleep for %s secs' % secs)
    time.sleep(secs)
    logger.info('sleeper: woke up - returning result')
    return ['sleeper', 'result']

def callback(r):
    id,result=r
    for func in _CALLBACKS[id]:
        func(result)

def on_sleeper_result(r):
    if isinstance(r, Exception):
        logger.error('on_sleeper_result: got error: %s' % r)
    else:
        logger.info('on_sleeper_result: got result: %s' % r)

if __name__=='__main__':
    pool=mp.Pool()
    pool.apply_async(delegate,args=(sleeper, -3),kwds={'id':1},
                     callback=callback)
    attach(1,on_sleeper_result)
    pool.apply_async(delegate,args=(sleeper, 3),kwds={'id':2},
                     callback=callback)
    attach(2,on_sleeper_result)    
    while 1:
        logger.info('main: loop')
        time.sleep(1)

使用多处理在GUI应用程序中进行异步调用

2 个答案: