Python中如何在实现把通用进程池装配在不同的类上实现类方法的并行处理

在量化交易编码中，通常可以把一个策略或者完整算法写成一个类，以便组合在一个完整工程中。 有时这个类的某些方法需要利用并行计算以加速处理，python中一般用进程池（concurrent.future）进行并行计算，以有效加快处理速度

with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
            futures = [executor.submit(self.evaluate_item, item) for item in n_list]
            for future in concurrent.futures.as_completed(futures):
                print(future.result())
                self.result.append(future.result())

但进程池的使用比线程池（线程池存在GIL限制，基本无法提升处理速度）要严格，一般在主程序if name == ‘main’:中使用。

能否实现一个通用并行处理器可以加载不同的类，对相近的类方法实施加速处理呢？ 可以使用继承关系，让算法类（子类）继承通用并行处理器类（父类）

*FatherMultiPro.py:*
import concurrent.futures
from abc import ABCMeta,abstractmethod

#父类，完成进程池，子类通过重载父类方法调用进程池
class FatherMultiPro:

    def __init__(self, n_list):
        '''
        Constructor
        '''
        self.result=[]
        
        with concurrent.futures.ProcessPoolExecutor(max_workers=3) as executor:
            futures = [executor.submit(**self.evaluate_item**, **item**) for item in n_list]
            for future in concurrent.futures.as_completed(futures):
                print(future.result())
                self.result.append(future.result())
    
    @abstractmethod
    **def evaluate_item(self,x):**
        pass
    
    
    def getList(self):
        return self.result


#子类
class MyMulti(FatherMultiPro):
    
    def __init__(self,n_list):
        
        self.list=n_list
        
    def sta(self):
        super(MyMulti,self).__init__(self.list)
    def evaluate_item(self,x):
        # 计算总和，这里只是为了消耗时间
        print('aaa')
        result_item = self.count(x)
        # 打印输入和输出结果
        return result_item
    
    def  count(self,number) :
        for i in range(0, 10000000):
                i=i+1
        return i * number   
    
    def getList(self):
        return super(MyMulti,self).getList()

*MyMulti.py*
from trade.quant.FatherMultiPro import MyMulti

if __name__ == '__main__':
    number_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    
    mp=MyMulti(number_list)
    
    mp.sta()
    
    print('pp:',mp.getList())

class FatherMultiPro就是一个通用加速器，需要加速的方法可以写成虚拟方法； 算法类（MyMulti.py）只要实现这个虚拟方法，就可以利用并行处理能力进行加速处理。

结果（这里使用了3个进程并行处理 max_workers=3）

aaa
aaa
aaa
aaa
10000000
aaa
20000000
aaa
30000000
aaa
40000000
aaa
60000000
aaa
50000000
aaa
70000000
80000000
90000000
100000000
pp: [10000000, 20000000, 30000000, 40000000, 60000000, 50000000, 70000000, 80000000, 90000000, 100000000]

这是有实际意义的例如，量化方法中，对不同的证券，股票或者其他标的量化策略就可以看成是不同的算法类，可以利用通用加速器分别不同标的时间序列的进行加速处理，提高效率

抛砖引玉，欢迎吐槽