다중 처리:클래스에 정의된 함수에서 Pool.map을 사용하는 방법은 무엇입니까?

다중 처리:클래스에 정의된 함수에서 Pool.map을 사용하는 방법은 무엇입니까?

다음과 같은 작업을 실행할 때:

from multiprocessing import Pool

p = Pool(5)
def f(x):
     return x*x

p.map(f, [1,2,3])

잘 작동합니다.그러나 이것을 클래스의 함수로 사용:

class calculate(object):
    def run(self):
        def f(x):
            return x*x

        p = Pool()
        return p.map(f, [1,2,3])

cl = calculate()
print cl.run()

다음 오류가 발생합니다.

Exception in thread Thread-1:
Traceback (most recent call last):
  File "/sw/lib/python2.6/threading.py", line 532, in __bootstrap_inner
    self.run()
  File "/sw/lib/python2.6/threading.py", line 484, in run
    self.__target(*self.__args, **self.__kwargs)
  File "/sw/lib/python2.6/multiprocessing/pool.py", line 225, in _handle_tasks
    put(task)
PicklingError: Can't pickle <type 'function'>: attribute lookup __builtin__.function failed

저는 알렉스 마텔리가 같은 종류의 문제를 다루는 게시물을 본 적이 있지만, 그것은 충분히 명시적이지 않았습니다.

"멀티프로세싱"을 사용하는 코드이기 때문에 지금까지 게시된 코드를 사용할 수 없었습니다.풀"은 "다중 처리"를 사용하지 않는 람다 식 및 코드에서는 작동하지 않습니다.풀"은 작업 항목 수만큼 프로세스를 생성합니다.

코드 s.t.를 수정했습니다. 미리 정의된 양의 작업자를 생성하고 유휴 작업자가 있는 경우에만 입력 목록을 반복합니다.또한 workers s.t. ctrl-cworks에 대해 예상대로 "daemon" 모드를 활성화했습니다.

import multiprocessing


def fun(f, q_in, q_out):
    while True:
        i, x = q_in.get()
        if i is None:
            break
        q_out.put((i, f(x)))


def parmap(f, X, nprocs=multiprocessing.cpu_count()):
    q_in = multiprocessing.Queue(1)
    q_out = multiprocessing.Queue()

    proc = [multiprocessing.Process(target=fun, args=(f, q_in, q_out))
            for _ in range(nprocs)]
    for p in proc:
        p.daemon = True
        p.start()

    sent = [q_in.put((i, x)) for i, x in enumerate(X)]
    [q_in.put((None, None)) for _ in range(nprocs)]
    res = [q_out.get() for _ in range(len(sent))]

    [p.join() for p in proc]

    return [x for i, x in sorted(res)]


if __name__ == '__main__':
    print(parmap(lambda i: i * 2, [1, 2, 3, 4, 6, 7, 8]))

다중 처리 및 피클링은 표준 라이브러리 밖으로 점프하지 않는 한 중단되고 제한됩니다.

포크를 사용하는 경우multiprocessing라고 하는pathos.multiprocesssing는 multiprocessing의 class와 method를 할 수 .map기들능. 는. 는.dill는 대사다니됩용 됩니다.pickle또는cPickle,그리고.dill파이썬에서 거의 모든 것을 직렬화할 수 있습니다.

pathos.multiprocessing 기능을 합니다…. 이 은 …을 사용할 수 있습니다.map인수( 가여개인예함수러수변예▁with)를 갖는 함수:map(math.pow, [1,2,3], [4,5,6]))

토론 참조:멀티프로세싱과 딜이 함께 할 수 있는 것은 무엇입니까?

그리고: http://matthewrocklin.com/blog/work/2013/12/05/Parallelism-and-Serialization

그것은 심지어 당신이 처음에 작성한 코드를 수정 없이 그리고 통역사로부터 처리합니다.왜 하나의 사건에 더 취약하고 구체적인 것이 있습니까?

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> class calculate(object):
...  def run(self):
...   def f(x):
...    return x*x
...   p = Pool()
...   return p.map(f, [1,2,3])
... 
>>> cl = calculate()
>>> print cl.run()
[1, 4, 9]

여기에서 코드를 확인하십시오. https://github.com/uqfoundation/pathos

그리고, 그것이 할 수 있는 것을 조금 더 보여주기 위해:

>>> from pathos.multiprocessing import ProcessingPool as Pool
>>> 
>>> p = Pool(4)
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> x = [0,1,2,3]
>>> y = [4,5,6,7]
>>> 
>>> p.map(add, x, y)
[4, 6, 8, 10]
>>> 
>>> class Test(object):
...   def plus(self, x, y): 
...     return x+y
... 
>>> t = Test()
>>> 
>>> p.map(Test.plus, [t]*4, x, y)
[4, 6, 8, 10]
>>> 
>>> res = p.amap(t.plus, x, y)
>>> res.get()
[4, 6, 8, 10]

저는 또한 pool.map이 수용할 수 있는 함수의 종류에 대한 제한 때문에 짜증이 났습니다.저는 이것을 피하기 위해 다음과 같이 썼습니다.파맵을 재귀적으로 사용하는 경우에도 작동하는 것으로 보입니다.

from multiprocessing import Process, Pipe
from itertools import izip

def spawn(f):
    def fun(pipe, x):
        pipe.send(f(x))
        pipe.close()
    return fun

def parmap(f, X):
    pipe = [Pipe() for x in X]
    proc = [Process(target=spawn(f), args=(c, x)) for x, (p, c) in izip(X, pipe)]
    [p.start() for p in proc]
    [p.join() for p in proc]
    return [p.recv() for (p, c) in pipe]

if __name__ == '__main__':
    print parmap(lambda x: x**x, range(1, 5))

현재 당신의 문제에 대한 해결책은 없습니다. 제가 알기로는 당신이 제공하는 기능입니다.map()모듈 가져오기를 통해 액세스할 수 있어야 합니다.로버트의 작동하는 입니다: 이것이로코작이동는유:.f()다음 코드를 가져오면 얻을 수 있습니다.

def f(x):
    return x*x

class Calculate(object):
    def run(self):
        p = Pool()
        return p.map(f, [1,2,3])

if __name__ == '__main__':
    cl = Calculate()
    print cl.run()

Windows 플랫폼에 대한 권장 사항("의도하지 않은 부작용을 일으키지 않고 메인 모듈을 새 Python 인터프리터로 안전하게 가져올 수 있는지 확인")을 따르기 때문에 실제로 "메인" 섹션을 추가했습니다.

앞에 했습니다.CalculatePEP 8을 따르기 위해. :)

에 의한 의 데이터를 보내면 수 .pipe.send()가 에.pipe.join() 해결책은를 읽기 전에 것입니다.join()아이를 속입니다.또한 아이는 교착 상태를 방지하기 위해 파이프의 부모 끝을 닫아야 합니다.아래 코드가 그것을 수정합니다.또한 이것을 알아두시기 바랍니다.parmap는 서에요 당하공생다니에서 합니다.X보다 고급적인 솔루션은 사용하는 것입니다.multiprocessing.cpu_count()누다를 X반환하기 전에 결과를 병합합니다.저는 mrule에 의한 멋진 답변의 간결함을 망치지 않기 위해 그것을 독자들에게 연습으로 남깁니다.;)

from multiprocessing import Process, Pipe
from itertools import izip

def spawn(f):
    def fun(ppipe, cpipe,x):
        ppipe.close()
        cpipe.send(f(x))
        cpipe.close()
    return fun

def parmap(f,X):
    pipe=[Pipe() for x in X]
    proc=[Process(target=spawn(f),args=(p,c,x)) for x,(p,c) in izip(X,pipe)]
    [p.start() for p in proc]
    ret = [p.recv() for (p,c) in pipe]
    [p.join() for p in proc]
    return ret

if __name__ == '__main__':
    print parmap(lambda x:x**x,range(1,5))

저도 이것 때문에 고생했어요.단순화된 예로서 클래스의 데이터 멤버로서의 기능이 있었습니다.

from multiprocessing import Pool
import itertools
pool = Pool()
class Example(object):
    def __init__(self, my_add): 
        self.f = my_add  
    def add_lists(self, list1, list2):
        # Needed to do something like this (the following line won't work)
        return pool.map(self.f,list1,list2)  

같은 클래스 내의 Pool.map() 호출에서 self.f 함수를 사용해야 했고 self.f는 튜플을 인수로 사용하지 않았습니다.이 함수는 클래스에 포함되어 있었기 때문에 다른 답변이 제시한 포장지 유형을 어떻게 작성해야 할지 잘 모르겠습니다.

저는 튜플/목록을 사용하는 다른 래퍼를 사용하여 이 문제를 해결했습니다. 여기서 첫 번째 요소는 함수이고 나머지 요소는 eval_func_tuple(f_args)이라는 함수의 인수입니다.이를 사용하여 문제가 있는 행을 return pool.map(eval_func_tuple,ittertools.izip(ittertools.repeat(self.f), list1, list2)로 바꿀 수 있습니다.다음은 전체 코드입니다.

파일: util.파이의

def add(a, b): return a+b

def eval_func_tuple(f_args):
    """Takes a tuple of a function and args, evaluates and returns result"""
    return f_args[0](*f_args[1:])  

파일: 메인.파이의

from multiprocessing import Pool
import itertools
import util  

pool = Pool()
class Example(object):
    def __init__(self, my_add): 
        self.f = my_add  
    def add_lists(self, list1, list2):
        # The following line will now work
        return pool.map(util.eval_func_tuple, 
            itertools.izip(itertools.repeat(self.f), list1, list2)) 

if __name__ == '__main__':
    myExample = Example(util.add)
    list1 = [1, 2, 3]
    list2 = [10, 20, 30]
    print myExample.add_lists(list1, list2)  

main.py 을 실행하면 [11, 22, 33]이 제공됩니다.eval_func_tuple도 키워드 인수를 사용하도록 수정할 수 있습니다.

다른 한편으로, 다른 답변에서, "파맵" 기능은 사용 가능한 CPU 수보다 더 많은 프로세스의 경우에 더 효율적으로 만들 수 있습니다.아래 편집본을 복사합니다.이것은 저의 첫 번째 게시물이고 저는 제가 원래 답변을 직접 수정해야 하는지 확신할 수 없었습니다.변수 이름도 몇 개 바꿨습니다.

from multiprocessing import Process, Pipe  
from itertools import izip  

def spawn(f):  
    def fun(pipe,x):  
        pipe.send(f(x))  
        pipe.close()  
    return fun  

def parmap(f,X):  
    pipe=[Pipe() for x in X]  
    processes=[Process(target=spawn(f),args=(c,x)) for x,(p,c) in izip(X,pipe)]  
    numProcesses = len(processes)  
    processNum = 0  
    outputList = []  
    while processNum < numProcesses:  
        endProcessNum = min(processNum+multiprocessing.cpu_count(), numProcesses)  
        for proc in processes[processNum:endProcessNum]:  
            proc.start()  
        for proc in processes[processNum:endProcessNum]:  
            proc.join()  
        for proc,c in pipe[processNum:endProcessNum]:  
            outputList.append(proc.recv())  
        processNum = endProcessNum  
    return outputList    

if __name__ == '__main__':  
    print parmap(lambda x:x**x,range(1,5))         

이 질문은 8년 10개월 전에 한 것으로 알고 있습니다만, 저의 해결책을 제시하고자 합니다.

from multiprocessing import Pool

class Test:

    def __init__(self):
        self.main()

    @staticmethod
    def methodForMultiprocessing(x):
        print(x*x)

    def main(self):
        if __name__ == "__main__":
            p = Pool()
            p.map(Test.methodForMultiprocessing, list(range(1, 11)))
            p.close()

TestObject = Test()

당신은 당신의 수업을 정적인 방법으로 만들기만 하면 됩니다.그러나 클래스 방법으로도 가능합니다.

from multiprocessing import Pool

class Test:

    def __init__(self):
        self.main()

    @classmethod
    def methodForMultiprocessing(cls, x):
        print(x*x)

    def main(self):
        if __name__ == "__main__":
            p = Pool()
            p.map(Test.methodForMultiprocessing, list(range(1, 11)))
            p.close()

TestObject = Test()

Python 3.7.3에서 테스트됨

저는 이것이 6년 전에 질문되었다는 것을 압니다. 하지만 위의 제안 중 일부가 끔찍하게 복잡해 보이기 때문에 제 해결책을 추가하고 싶었습니다. 하지만 제 해결책은 사실 매우 간단했습니다.

제가 해야 할 일은 도우미 함수에 pool.map() 호출을 랩하는 것이었습니다.메서드에 대한 인수와 함께 클래스 개체를 전달합니다. 이는 약간 이와 유사합니다.

def run_in_parallel(args):
    return args[0].method(args[1])

myclass = MyClass()
method_args = [1,2,3,4,5,6]
args_map = [ (myclass, arg) for arg in method_args ]
pool = Pool()
pool.map(run_in_parallel, args_map)

저는 클라우스와 아간더스3의 답변을 받아 더 읽기 쉽고 한 파일에 담을 수 있는 문서화된 모듈을 만들었습니다.프로젝트에 추가할 수 있습니다.선택적인 진행 표시줄도 있습니다!

"""
The ``processes`` module provides some convenience functions
for using parallel processes in python.

Adapted from http://stackoverflow.com/a/16071616/287297

Example usage:

    print prll_map(lambda i: i * 2, [1, 2, 3, 4, 6, 7, 8], 32, verbose=True)

Comments:

"It spawns a predefined amount of workers and only iterates through the input list
 if there exists an idle worker. I also enabled the "daemon" mode for the workers so
 that KeyboardInterupt works as expected."

Pitfalls: all the stdouts are sent back to the parent stdout, intertwined.

Alternatively, use this fork of multiprocessing: 
https://github.com/uqfoundation/multiprocess
"""

# Modules #
import multiprocessing
from tqdm import tqdm

################################################################################
def apply_function(func_to_apply, queue_in, queue_out):
    while not queue_in.empty():
        num, obj = queue_in.get()
        queue_out.put((num, func_to_apply(obj)))

################################################################################
def prll_map(func_to_apply, items, cpus=None, verbose=False):
    # Number of processes to use #
    if cpus is None: cpus = min(multiprocessing.cpu_count(), 32)
    # Create queues #
    q_in  = multiprocessing.Queue()
    q_out = multiprocessing.Queue()
    # Process list #
    new_proc  = lambda t,a: multiprocessing.Process(target=t, args=a)
    processes = [new_proc(apply_function, (func_to_apply, q_in, q_out)) for x in range(cpus)]
    # Put all the items (objects) in the queue #
    sent = [q_in.put((i, x)) for i, x in enumerate(items)]
    # Start them all #
    for proc in processes:
        proc.daemon = True
        proc.start()
    # Display progress bar or not #
    if verbose:
        results = [q_out.get() for x in tqdm(range(len(sent)))]
    else:
        results = [q_out.get() for x in range(len(sent))]
    # Wait for them to finish #
    for proc in processes: proc.join()
    # Return results #
    return [x for i, x in sorted(results)]

################################################################################
def test():
    def slow_square(x):
        import time
        time.sleep(2)
        return x**2
    objs    = range(20)
    squares = prll_map(slow_square, objs, 4, verbose=True)
    print "Result: %s" % squares

EDIT: @alexander-mcfarlane 제안 및 테스트 기능 추가

클래스에 정의된 함수(클래스 내 함수 내에서도)는 실제로 피클이 되지 않습니다.그러나 이 방법은 다음과 같습니다.

def f(x):
    return x*x

class calculate(object):
    def run(self):
        p = Pool()
    return p.map(f, [1,2,3])

cl = calculate()
print cl.run()

Klausse의 방법을 수정한 이유는 작은 목록으로 나를 위해 작동하는 동안 아이템 수가 ~1000개 이상이 되면 중단되기 때문입니다.작업을 한 번에 하나씩 밀어내는 대신None정지 조건, 나는 입력 대기열을 한 번에 로드하고 프로세스가 비워질 때까지 갉아먹게 합니다.

from multiprocessing import cpu_count, Queue, Process

def apply_func(f, q_in, q_out):
    while not q_in.empty():
        i, x = q_in.get()
        q_out.put((i, f(x)))

# map a function using a pool of processes
def parmap(f, X, nprocs = cpu_count()):
    q_in, q_out   = Queue(), Queue()
    proc = [Process(target=apply_func, args=(f, q_in, q_out)) for _ in range(nprocs)]
    sent = [q_in.put((i, x)) for i, x in enumerate(X)]
    [p.start() for p in proc]
    res = [q_out.get() for _ in sent]
    [p.join() for p in proc]

    return [x for i,x in sorted(res)]

편집: 안타깝게도 지금 시스템에서 다음 오류가 발생했습니다.다중 처리 대기열 최대 크기 제한은 32767이며, 해결 방법이 도움이 되기를 바랍니다.

여기 제 해결책이 있습니다. 제 생각에는 여기 있는 대부분의 다른 사람들보다 덜 촌스럽다고 생각합니다.이것은 밤새의 대답과 비슷합니다.

someclasses = [MyClass(), MyClass(), MyClass()]

def method_caller(some_object, some_method='the method'):
    return getattr(some_object, some_method)()

othermethod = partial(method_caller, some_method='othermethod')

with Pool(6) as pool:
    result = pool.map(othermethod, someclasses)

수동으로 코드를 무시하면 문제 없이 코드를 실행할 수 있습니다.Pool클래스에 있는 개체 목록에서 개체가 아닙니다.pickle오류에서 알 수 있듯이 가능합니다.이 작업을 수행할 수 있습니다.__getstate__함수(여기도 참조)는 다음과 같습니다.그Pool객체는 찾기를 시도할 것입니다.__getstate__그리고.__setstate__기능을 실행하고 실행할 때 기능이 발견되면 실행합니다.map,map_async기타:

class calculate(object):
    def __init__(self):
        self.p = Pool()
    def __getstate__(self):
        self_dict = self.__dict__.copy()
        del self_dict['p']
        return self_dict
    def __setstate__(self, state):
        self.__dict__.update(state)

    def f(self, x):
        return x*x
    def run(self):
        return self.p.map(self.f, [1,2,3])

다음을 수행합니다.

cl = calculate()
cl.run()

는 출력을 제공합니다.

[1, 4, 9]

위의 코드를 파이썬 3.x에서 테스트해봤는데 작동합니다.

이것은 별로 좋은 해결책이 아닐 수도 있지만, 저의 경우에는 이렇게 해결합니다.

from multiprocessing import Pool

def foo1(data):
    self = data.get('slf')
    lst = data.get('lst')
    return sum(lst) + self.foo2()

class Foo(object):
    def __init__(self, a, b):
        self.a = a
        self.b = b

    def foo2(self):
        return self.a**self.b   

    def foo(self):
        p = Pool(5)
        lst = [1, 2, 3]
        result = p.map(foo1, (dict(slf=self, lst=lst),))
        return result

if __name__ == '__main__':
    print(Foo(2, 4).foo())

나는 합격해야 했습니다.self그 기능을 통해 우리 반의 속성과 기능에 접근해야 하기 때문에 내 기능에.이건 저한테 효과가 있어요.수정 및 제안은 언제든지 환영합니다.

여기 python3에서 멀티프로세싱 풀을 사용하기 위해 작성한 보일러 플레이트가 있습니다. 특히 python3.7.7은 테스트를 실행하는 데 사용되었습니다.다음을 사용하여 가장 빠른 실행 속도를 얻었습니다.imap_unordered시나리오를 연결하여 사용해 보십시오.사용할 수 있습니다.timeit아니면 그냥time.time()어떤 것이 당신에게 가장 잘 맞는지 알아내려고요.

import multiprocessing
import time

NUMBER_OF_PROCESSES = multiprocessing.cpu_count()
MP_FUNCTION = 'starmap'  # 'imap_unordered' or 'starmap' or 'apply_async'

def process_chunk(a_chunk):
    print(f"processig mp chunk {a_chunk}")
    return a_chunk


map_jobs = [1, 2, 3, 4]

result_sum = 0

s = time.time()
if MP_FUNCTION == 'imap_unordered':
    pool = multiprocessing.Pool(processes=NUMBER_OF_PROCESSES)
    for i in pool.imap_unordered(process_chunk, map_jobs):
        result_sum += i
elif MP_FUNCTION == 'starmap':
    pool = multiprocessing.Pool(processes=NUMBER_OF_PROCESSES)
    try:
        map_jobs = [(i, ) for i in map_jobs]
        result_sum = pool.starmap(process_chunk, map_jobs)
        result_sum = sum(result_sum)
    finally:
        pool.close()
        pool.join()
elif MP_FUNCTION == 'apply_async':
    with multiprocessing.Pool(processes=NUMBER_OF_PROCESSES) as pool:
        result_sum = [pool.apply_async(process_chunk, [i, ]).get() for i in map_jobs]
    result_sum = sum(result_sum)
print(f"result_sum is {result_sum}, took {time.time() - s}s")

의 시나리오에서 위의시오서에리.imap_unordered사실 나한테 최악의 성적을 내는 것 같아요.사례를 사용해 보고 실행하려는 시스템에서 벤치마킹하십시오.프로세스 풀에 대해서도 자세히 알아보십시오.건배!

이 접근 방식이 채택되었는지는 확실하지 않지만, 제가 사용하고 있는 작업은 다음과 같습니다.

from multiprocessing import Pool

t = None

def run(n):
    return t.f(n)

class Test(object):
    def __init__(self, number):
        self.number = number

    def f(self, x):
        print x * self.number

    def pool(self):
        pool = Pool(2)
        pool.map(run, range(10))

if __name__ == '__main__':
    t = Test(9)
    t.pool()
    pool = Pool(2)
    pool.map(run, range(10))

출력은 다음과 같아야 합니다.

0
9
18
27
36
45
54
63
72
81
0
9
18
27
36
45
54
63
72
81

class Calculate(object):
  # Your instance method to be executed
  def f(self, x, y):
    return x*y

if __name__ == '__main__':
  inp_list = [1,2,3]
  y = 2
  cal_obj = Calculate()
  pool = Pool(2)
  results = pool.map(lambda x: cal_obj.f(x, y), inp_list)

클래스의 각 인스턴스에 이 함수를 적용할 가능성이 있습니다.그렇다면 여기 그것에 대한 해결책도 있습니다.

class Calculate(object):
  # Your instance method to be executed
  def __init__(self, x):
    self.x = x

  def f(self, y):
    return self.x*y

if __name__ == '__main__':
  inp_list = [Calculate(i) for i in range(3)]
  y = 2
  pool = Pool(2)
  results = pool.map(lambda x: x.f(y), inp_list)

http://www.rueckstiess.net/research/snippets/show/ca1d7d90 및 http://qingkaikong.blogspot.com/2016/12/python-parallel-method-in-class.html 에서.

외부 함수를 만들고 클래스 자체 객체와 함께 시드할 수 있습니다.

from joblib import Parallel, delayed
def unwrap_self(arg, **kwarg):
    return square_class.square_int(*arg, **kwarg)

class square_class:
    def square_int(self, i):
        return i * i

    def run(self, num):
        results = []
        results = Parallel(n_jobs= -1, backend="threading")\
            (delayed(unwrap_self)(i) for i in zip([self]*len(num), num))
        print(results)

또는 joblib를 사용하지 않음

from multiprocessing import Pool
import time

def unwrap_self_f(arg, **kwarg):
    return C.f(*arg, **kwarg)

class C:
    def f(self, name):
        print 'hello %s,'%name
        time.sleep(5)
        print 'nice to meet you.'

    def run(self):
        pool = Pool(processes=2)
        names = ('frank', 'justin', 'osi', 'thomas')
        pool.map(unwrap_self_f, zip([self]*len(names), names))

if __name__ == '__main__':
    c = C()
    c.run()

aws 람다에서 다중 처리를 구현하려면 두 가지 방법이 있습니다.참고: 스레드 풀은 aws 람다에서 작동하지 않습니다.

1. aWS 팀에서 제공하는 예제 솔루션을 사용하십시오. 이 링크를 사용하십시오. https://aws.amazon.com/blogs/compute/parallel-processing-in-python-with-aws-lambda/

2. 이 패키지를 사용합니다. https://pypi.org/project/lambda-multiprocessing/

저는 두 솔루션 모두에서 람다 기능을 구현했으며 두 솔루션 모두 정상적으로 작동하고 있습니다. 여기서 제 코드를 공유할 수는 없지만 이 두 링크가 확실히 도움이 될 것입니다.

저는 두 번째 방법이 구현하기 더 쉽다는 것을 알게 되었습니다.

을 더 쉽게 수 . 를 들어, 예를들어, 이것더만몇몇있라다습도니들리러이브는드쉽게을▁to▁for▁there다있습▁example니▁libraries▁easier▁make▁are도들▁some▁also▁this예,.autothread(Python 3.6 이상에만 해당):

import autothread

class calculate(object):
    def run(self):
        @autothread.multiprocessed()
        def f(x: int):
            return x*x

        return f([1,2,3])

cl = calculate()
print(cl.run())

여러분은 또한 lox를 볼 수 있습니다.

언급URL : https://stackoverflow.com/questions/3288595/multiprocessing-how-to-use-pool-map-on-a-function-defined-in-a-class