基于运行的所有作业的聚合条件的Python多处理作业提交

基于Python多处理作业提交的所有运行作业的聚合条件

---

我有一项工作需要在Teradata数据库上做一些工作，并将db会话数作为参数。数据库对db会话数的最大限制为60。我是否可以使用多处理来有条件地处理作业，以便所有活动子进程中的sum（num_db_会话）>sum（num_db_会话）我已经解决了这个问题。下面的代码就是这样做的。关键要素包括：

1） 运行单独的守护进程将任务放入队列。此操作的目标函数执行业务流程

2） 将计数器实现为multiprocessing.value，它跟踪当前正在运行的会话数。计数器的实现取自

3） 实现一个multiprocessing.manager（）.list（）以跟踪未提交的作业

4） 使用毒药丸方法发送None*number\u的\u child\u进程来中断工作进程，如毒药丸方法中实现的。这是从

worker函数使用time.sleep（num_db_sessions）作为模拟工作负载的方法（更高的处理时间）

这是代码

import multiprocessing
import time
class Counter(object):
    def __init__(self, initval=0):
        self.val = multiprocessing.Value('i', initval)
        self.lock = multiprocessing.Lock()

    def increment(self,val):
        with self.lock:
            self.val.value += val

    def value(self):
        with self.lock:
            return self.val.value

def queue_manager(tasks,results,jobs_list,counter,max_num_db_sessions,num_consumers):
    proc_name = multiprocessing.current_process().name
    while len(jobs_list) > 0:
        current_counter = counter.value()
        available_sessions = max_num_db_sessions - current_counter
        if available_sessions > 0:
            prop_list = [(p,s) for p,s in jobs_list if s <= available_sessions]
            if (len(prop_list)) > 0:
                with multiprocessing.Lock():
                    print(prop_list[0])
                    tasks.put(prop_list[0][0])
                    jobs_list.remove(prop_list[0])

                counter.increment(prop_list[0][1])
                print("Process: {} -- submitted:{} Counter is:{} Sessions:{}".format(proc_name
                                                                          , prop_list[0][0]
                                                                          , current_counter
                                                                          , available_sessions)
                      )
        else:
            print("Process: {} -- Sleeping:{} Counter is:{} Sessions:{}".format(proc_name
                                                                                 , str(5)
                                                                                 , current_counter
                                                                                 , available_sessions)
            )
            time.sleep(5)
    else:
        for i in range(num_consumers):
            tasks.put(None)

def worker(tasks,counter,proc_list):
    proc_name = multiprocessing.current_process().name
    while True:
        obj = tasks.get()
        if obj is None:
            break
        name,age = [(name,sess) for name,sess in proc_list if name == obj][0]
        print("Process: {} -- Processing:{} Sleeping for:{} Counter is:{}".format(proc_name
                                                                              ,name
                                                                              ,age
                                                                              ,counter.value())
              )
        time.sleep(age)
        counter.increment(-age)
        print("Process: {} -- Exiting:{} Sleeping for:{} Counter is:{}".format(proc_name
                                                                              ,name
                                                                              ,age
                                                                              ,counter.value())
              )

if __name__ == '__main__':
    max_num_db_sessions = 60
    tasks = multiprocessing.JoinableQueue()
    results = multiprocessing.Queue() # This will be unused now. But will use it.
    mpmanager = multiprocessing.Manager()
    proc_list = [('A', 15), ('B', 15), ('C', 15), ('D', 15)
                , ('E', 1), ('F', 1), ('G', 1), ('H', 1)
                , ('I', 1), ('J', 1), ('K', 1), ('L', 1)
                , ('M', 2), ('N', 1), ('O', 1), ('P', 1)
                , ('Q', 2), ('R', 2), ('S', 2), ('T', 2)
                , ('U', 2), ('V', 2), ('W', 2), ('X', 2)
                , ('Y', 2), ('Z', 2)]
    jobs_list = mpmanager.list(proc_list)
    counter = Counter(0)
    num_cpu = 3
    d = multiprocessing.Process(name='Queue_manager_proc'
                                ,target=queue_manager
                                ,args=(tasks, results, jobs_list, counter
                                       , max_num_db_sessions, num_cpu)
                                )
    d.daemon = True
    d.start()
    jobs = []
    for i in range(num_cpu):
        p = multiprocessing.Process(name="Worker_proc_{}".format(str(i+1))
                                    ,target=worker
                                    ,args=(tasks,counter,proc_list)
                                    )
        jobs.append(p)
        p.start()

    for job in jobs:
        job.join()

    d.join()

导入多处理
导入时间
类计数器（对象）：
def uuu init uuu（self，initval=0）：
self.val=多处理.Value（'i'，initval）
self.lock=multiprocessing.lock（）
def增量（自身，val）：
使用self.lock：
self.val.value+=val
def值（自身）：
使用self.lock：
返回self.val.value
def队列管理器（任务、结果、作业列表、计数器、max_num_db_会话、num_使用者）：
proc_name=多处理。当前_进程（）。名称
而len（作业列表）>0：
当前计数器=计数器值（）
可用会话=最大会话数会话数-当前会话计数器
如果可用\u会话>0：
prop_list=[（p，s）表示作业列表中的p，s，如果s 0：
使用multiprocessing.Lock（）：
打印（项目列表[0]）
任务.放置（属性列表[0][0]）
作业列表。删除（属性列表[0]）
计数器增量（属性列表[0][1]）
打印（“进程：{}--submitted:{}计数器为：{}会话：{}”。格式（proc_名称）
，道具清单[0][0]
，当前计数器
，可供选择（课程）
)
其他：
打印（“进程：{}--Sleeping:{}计数器是：{}会话：{}”。格式（proc_名称）
，str（5）
，当前计数器
，可供选择（课程）
)
时间。睡眠（5）
其他：
对于范围内的i（消费者数量）：
任务。放置（无）
def工作者（任务、计数器、过程列表）：
proc_name=多处理。当前_进程（）。名称
尽管如此：
obj=tasks.get（）
如果obj为无：
打破
name，age=[（name，sess）表示name，如果name==obj，则进程列表中的sess][0]
打印（“进程：{}--Processing:{}睡眠：{}计数器为：{}”。格式（proc_名称）
名称
岁
，counter.value（））
)
时间、睡眠（年龄）
计数器。增量（-age）
打印（“进程：{}——退出：{}睡眠：{}计数器为：{}”。格式（proc_名称）
名称
岁
，counter.value（））
)
如果uuuu name uuuuuu='\uuuuuuu main\uuuuuuu'：
最大会话数=60
任务=多处理。JoinableQueue（）
results=multiprocessing.Queue（）#这将不再使用。但将使用它。
mpmanager=multiprocessing.Manager（）
进程列表=[（'A'，15），（'B'，15），（'C'，15），（'D'，15）
，（'E'，1），（'F'，1），（'G'，1），（'H'，1）
，（'I'，1），（'J'，1），（'K'，1），（'L'，1）
，（'M'，2），（'N'，1），（'O'，1），（'P'，1）
，（'Q'，2），（'R'，2），（'S'，2），（'T'，2）
，（'U'，2），（'V'，2），（'W'，2），（'X'，2）
，（'Y'，2），（'Z'，2）]
作业列表=mpmanager.list（进程列表）
计数器=计数器（0）
num_cpu=3
d=多处理。进程（name='Queue\u manager\u proc'
，target=队列管理器
，args=（任务、结果、作业列表、计数器
，max_num_db_会话，num_cpu）
)
d、 daemon=True
d、 开始（）
工作=[]
对于范围内的i（num\u cpu）：
p=multiprocessing.Process（name=“Worker_proc_{}”.format（str（i+1））
，目标=工人
，args=（任务、计数器、进程列表）
)
jobs.append（p）
p、 开始（）
工作中的工作：
job.join（）
d、 加入

import multiprocessing
import time
class Counter(object):
    def __init__(self, initval=0):
        self.val = multiprocessing.Value('i', initval)
        self.lock = multiprocessing.Lock()

    def increment(self,val):
        with self.lock:
            self.val.value += val

    def value(self):
        with self.lock:
            return self.val.value

def queue_manager(tasks,results,jobs_list,counter,max_num_db_sessions,num_consumers):
    proc_name = multiprocessing.current_process().name
    while len(jobs_list) > 0:
        current_counter = counter.value()
        available_sessions = max_num_db_sessions - current_counter
        if available_sessions > 0:
            prop_list = [(p,s) for p,s in jobs_list if s <= available_sessions]
            if (len(prop_list)) > 0:
                with multiprocessing.Lock():
                    print(prop_list[0])
                    tasks.put(prop_list[0][0])
                    jobs_list.remove(prop_list[0])

                counter.increment(prop_list[0][1])
                print("Process: {} -- submitted:{} Counter is:{} Sessions:{}".format(proc_name
                                                                          , prop_list[0][0]
                                                                          , current_counter
                                                                          , available_sessions)
                      )
        else:
            print("Process: {} -- Sleeping:{} Counter is:{} Sessions:{}".format(proc_name
                                                                                 , str(5)
                                                                                 , current_counter
                                                                                 , available_sessions)
            )
            time.sleep(5)
    else:
        for i in range(num_consumers):
            tasks.put(None)

def worker(tasks,counter,proc_list):
    proc_name = multiprocessing.current_process().name
    while True:
        obj = tasks.get()
        if obj is None:
            break
        name,age = [(name,sess) for name,sess in proc_list if name == obj][0]
        print("Process: {} -- Processing:{} Sleeping for:{} Counter is:{}".format(proc_name
                                                                              ,name
                                                                              ,age
                                                                              ,counter.value())
              )
        time.sleep(age)
        counter.increment(-age)
        print("Process: {} -- Exiting:{} Sleeping for:{} Counter is:{}".format(proc_name
                                                                              ,name
                                                                              ,age
                                                                              ,counter.value())
              )

if __name__ == '__main__':
    max_num_db_sessions = 60
    tasks = multiprocessing.JoinableQueue()
    results = multiprocessing.Queue() # This will be unused now. But will use it.
    mpmanager = multiprocessing.Manager()
    proc_list = [('A', 15), ('B', 15), ('C', 15), ('D', 15)
                , ('E', 1), ('F', 1), ('G', 1), ('H', 1)
                , ('I', 1), ('J', 1), ('K', 1), ('L', 1)
                , ('M', 2), ('N', 1), ('O', 1), ('P', 1)
                , ('Q', 2), ('R', 2), ('S', 2), ('T', 2)
                , ('U', 2), ('V', 2), ('W', 2), ('X', 2)
                , ('Y', 2), ('Z', 2)]
    jobs_list = mpmanager.list(proc_list)
    counter = Counter(0)
    num_cpu = 3
    d = multiprocessing.Process(name='Queue_manager_proc'
                                ,target=queue_manager
                                ,args=(tasks, results, jobs_list, counter
                                       , max_num_db_sessions, num_cpu)
                                )
    d.daemon = True
    d.start()
    jobs = []
    for i in range(num_cpu):
        p = multiprocessing.Process(name="Worker_proc_{}".format(str(i+1))
                                    ,target=worker
                                    ,args=(tasks,counter,proc_list)
                                    )
        jobs.append(p)
        p.start()

    for job in jobs:
        job.join()

    d.join()