파이썬에서 비동기 메소드 호출?

파이썬 에서 비동기 메소드 호출을위한 라이브러리가 있는지 궁금합니다 . 다음과 같은 일을 할 수 있다면 좋을 것입니다

@async
def longComputation():
    <code>


token = longComputation()
token.registerCallback(callback_function)
# alternative, polling
while not token.finished():
    doSomethingElse()
    if token.finished():
        result = token.result()

또는 비동기식이 아닌 루틴을 비동기식으로 호출

def longComputation()
    <code>

token = asynccall(longComputation())

언어 핵심에서보다 정교한 전략을 갖는 것이 좋을 것입니다. 이것이 고려 되었습니까?

Python 2.6에 추가 된 다중 처리 모듈을 사용할 수 있습니다 . 프로세스 풀을 사용하고 다음을 사용하여 비동기 적으로 결과를 얻을 수 있습니다.

apply_async(func[, args[, kwds[, callback]]])

예 :

from multiprocessing import Pool

def f(x):
    return x*x

if __name__ == '__main__':
    pool = Pool(processes=1)              # Start a worker processes.
    result = pool.apply_async(f, [10], callback) # Evaluate "f(10)" asynchronously calling callback when finished.

이것은 하나의 대안 일뿐입니다. 이 모듈은 원하는 것을 달성하기 위해 많은 기능을 제공합니다. 또한 이것으로 데코레이터를 만드는 것은 정말 쉽습니다.

다음과 같은 것 :

import threading

thr = threading.Thread(target=foo, args=(), kwargs={})
thr.start() # Will run "foo"
....
thr.is_alive() # Will return whether foo is running currently
....
thr.join() # Will wait till "foo" is done

자세한 내용은 https://docs.python.org/library/threading.html 의 설명서를 참조 하십시오.

Python 3.5부터는 비동기 함수에 향상된 생성기를 사용할 수 있습니다.

import asyncio
import datetime

향상된 생성기 구문 :

@asyncio.coroutine
def display_date(loop):
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        yield from asyncio.sleep(1)


loop = asyncio.get_event_loop()
# Blocking call which returns when the display_date() coroutine is done
loop.run_until_complete(display_date(loop))
loop.close()

새로운 async/await문법 :

async def display_date(loop):
    end_time = loop.time() + 5.0
    while True:
        print(datetime.datetime.now())
        if (loop.time() + 1.0) >= end_time:
            break
        await asyncio.sleep(1)


loop = asyncio.get_event_loop()
# Blocking call which returns when the display_date() coroutine is done
loop.run_until_complete(display_date(loop))
loop.close()

그것은 언어 핵심이 아니지만 원하는 것을 수행하는 매우 성숙한 라이브러리는 Twisted 입니다. 콜백이나 오류 처리기 ( "errbacks")를 연결할 수있는 Deferred 객체를 소개합니다. 지연은 기본적으로 함수가 결과를 가져 오는 "약속"입니다.

약간 까다 롭지 만 데코레이터를 구현하여 함수를 비동기식으로 만들 수 있습니다. 이 multiprocessing모듈은 작은 단점과 임의의 제한 사항으로 가득 차 있습니다. 친숙한 인터페이스 뒤에 모듈을 캡슐화해야하는 더 많은 이유가 있습니다.

from inspect import getmodule
from multiprocessing import Pool


def async(decorated):
    r'''Wraps a top-level function around an asynchronous dispatcher.

        when the decorated function is called, a task is submitted to a
        process pool, and a future object is returned, providing access to an
        eventual return value.

        The future object has a blocking get() method to access the task
        result: it will return immediately if the job is already done, or block
        until it completes.

        This decorator won't work on methods, due to limitations in Python's
        pickling machinery (in principle methods could be made pickleable, but
        good luck on that).
    '''
    # Keeps the original function visible from the module global namespace,
    # under a name consistent to its __name__ attribute. This is necessary for
    # the multiprocessing pickling machinery to work properly.
    module = getmodule(decorated)
    decorated.__name__ += '_original'
    setattr(module, decorated.__name__, decorated)

    def send(*args, **opts):
        return async.pool.apply_async(decorated, args, opts)

    return send

아래 코드는 데코레이터 사용법을 보여줍니다.

@async
def printsum(uid, values):
    summed = 0
    for value in values:
        summed += value

    print("Worker %i: sum value is %i" % (uid, summed))

    return (uid, summed)


if __name__ == '__main__':
    from random import sample

    # The process pool must be created inside __main__.
    async.pool = Pool(4)

    p = range(0, 1000)
    results = []
    for i in range(4):
        result = printsum(i, sample(p, 100))
        results.append(result)

    for result in results:
        print("Worker %i: sum value is %i" % result.get())

실제 상황에서는 데코레이터에 대해 조금 더 자세히 설명하여 디버깅 (향후 인터페이스를 유지하면서) 또는 예외 처리 기능을 해제 할 수있는 방법을 제공합니다. 그러나 이것이 원리를 충분히 보여줍니다.

다만

import threading, time

def f():
    print "f started"
    time.sleep(3)
    print "f finished"

threading.Thread(target=f).start()

eventlet을 사용할 수 있습니다. 동기 코드 인 것처럼 보이지만 네트워크를 통해 비동기 적으로 작동하도록 할 수 있습니다.

다음은 초소형 크롤러의 예입니다.

urls = ["http://www.google.com/intl/en_ALL/images/logo.gif",
     "https://wiki.secondlife.com/w/images/secondlife.jpg",
     "http://us.i1.yimg.com/us.yimg.com/i/ww/beta/y3.gif"]

import eventlet
from eventlet.green import urllib2

def fetch(url):

  return urllib2.urlopen(url).read()

pool = eventlet.GreenPool()

for body in pool.imap(fetch, urls):
  print "got body", len(body)

내 해결책은 다음과 같습니다.

import threading

class TimeoutError(RuntimeError):
    pass

class AsyncCall(object):
    def __init__(self, fnc, callback = None):
        self.Callable = fnc
        self.Callback = callback

    def __call__(self, *args, **kwargs):
        self.Thread = threading.Thread(target = self.run, name = self.Callable.__name__, args = args, kwargs = kwargs)
        self.Thread.start()
        return self

    def wait(self, timeout = None):
        self.Thread.join(timeout)
        if self.Thread.isAlive():
            raise TimeoutError()
        else:
            return self.Result

    def run(self, *args, **kwargs):
        self.Result = self.Callable(*args, **kwargs)
        if self.Callback:
            self.Callback(self.Result)

class AsyncMethod(object):
    def __init__(self, fnc, callback=None):
        self.Callable = fnc
        self.Callback = callback

    def __call__(self, *args, **kwargs):
        return AsyncCall(self.Callable, self.Callback)(*args, **kwargs)

def Async(fnc = None, callback = None):
    if fnc == None:
        def AddAsyncCallback(fnc):
            return AsyncMethod(fnc, callback)
        return AddAsyncCallback
    else:
        return AsyncMethod(fnc, callback)

요청한대로 정확하게 작동합니다.

@Async
def fnc():
    pass

이와 같은 것이 저에게 효과적이며 함수를 호출 할 수 있으며 새로운 스레드로 전달됩니다.

from thread import start_new_thread

def dowork(asynchronous=True):
    if asynchronous:
        args = (False)
        start_new_thread(dowork,args) #Call itself on a new thread.
    else:
        while True:
            #do something...
            time.sleep(60) #sleep for a minute
    return

스레드를 사용하지 않는 이유가 있습니까? threading수업을 사용할 수 있습니다 . finished()기능 대신을 사용하십시오 isAlive(). 이 result()함수 join()는 스레드를 수행하고 결과를 검색 할 수 있습니다. 그리고 가능하면 run()and __init__함수를 재정 의하여 생성자에 지정된 함수를 호출하고 값을 클래스의 인스턴스에 저장합니다.

synchronize.futures (Python 3.2에 추가)를 사용할 수 있습니다 .

import time
from concurrent.futures import ThreadPoolExecutor


def long_computation(duration):
    for x in range(0, duration):
        print(x)
        time.sleep(1)
    return duration * 2


print('Use polling')
with ThreadPoolExecutor(max_workers=1) as executor:
    future = executor.submit(long_computation, 5)
    while not future.done():
        print('waiting...')
        time.sleep(0.5)

    print(future.result())

print('Use callback')
executor = ThreadPoolExecutor(max_workers=1)
future = executor.submit(long_computation, 5)
future.add_done_callback(lambda f: print(f.result()))

print('waiting for callback')

executor.shutdown(False)  # non-blocking

print('shutdown invoked')

프로세스를 사용할 수 있습니다. 당신이 그것을 실행하는 동안 영원히 네트워킹과 같은 동안 사용하십시오 :

from multiprocessing import Process
def foo():
    while 1:
        # Do something

p = Process(target = foo)
p.start()

한 번만 실행하려면 다음과 같이하십시오.

from multiprocessing import Process
def foo():
    # Do something

p = Process(target = foo)
p.start()
p.join()