Question

如果我使用start_new_thread启动一个线程，并且我想要同时运行n个独立函数，我会执行以下操作：

def foo1(x):
    print "foo1"
    time.sleep(5)

def foo2(x):
    print "foo2"
    time.sleep(1)

func_list = [foo1,foo2]

for k,j in enumerate(func_list):
    thread.start_new_thread(func_list[k],(1 ,))

这两个函数具有完全相同的代码，但这两个函数也是独立的，因为它们将消息发送到独立的ZMQ套接字（在发送回消息以便在{{1}内进行处理之前，它依次等待来自外部API的repsonse }）。

foo可能需要5秒才能完成处理，具体取决于API的响应时间和有效负载的大小，因此问题是如果我尝试在新线程中再次触发它，仍处理，ZMQ套接字引发异常（已经看过git，这不是bug）

因此，如果foo1正忙，则foo2可用，如果foo2忙，则foo（n）可能可用（最多为foo15），因此有大量工作人员可用。但是，我如何判断哪个功能正忙，如果它正忙于等待完成，或者其他工作人员可用，请改用它们？

请记住，我不能只调整相同功能的15个线程，因为无论出于什么意图和目的，它们都是独立的。

有人可以帮忙，这是我为自己创造的一个非常令人困惑的问题。感谢。

EDIT @ martineau -

我有我导入的套接字列表，我希望我不必这样做，但我使用的API没有http连接的限制（在合理范围内），但限制了每个人可以处理的请求数量。因此，更多的连接是提高速度的唯一途径。

下面是作业的设置 - 我一次处理10条记录，对应于我使用API保持活动的10个连接。我只是在汇集线程，并且如果一个忙，那么就会放弃使另一个线程运行的幽灵（这有点太复杂），因此如果一个线程需要5秒，它将延迟下一批10个。这是一个妥协。

foo1

这就是这个：

import socket_handler_a, socket_handler_b ...

def multi_call(reduce_kp, exe_func):

        def trd_call_a(x,y):
                exe_func(socket_handler_a(x),y)

        def trd_call_b(x,y):
                exe_func(socket_handler_b(x),y)

        def trd_call_c(x,y):
                exe_func(socket_handler_c(x),y)

        def trd_call_d(x,y):
                exe_func(socket_handler_d(x),y)

        def trd_call_e(x,y):
                exe_func(socket_handler_e(x),y)

        def trd_call_f(x,y):
                exe_func(socket_handler_f(x),y)

        def trd_call_g(x,y):
                exe_func(socket_handler_g(x),y)

        def trd_call_h(x,y):
                exe_func(socket_handler_h(x),y)

        def trd_call_i(x,y):
                exe_func(socket_handler_i(x),y)

        def trd_call_j(x,y):
                exe_func(socket_handler_j(x),y)

        func_list = [trd_call_a, trd_call_b,
                     trd_call_c, trd_call_d,
                     trd_call_e, trd_call_f,
                     trd_call_g, trd_call_h,
                     trd_call_i, trd_call_j]

        def chunks_(l, n):
                for i in range(0, len(l), n):
                    yield l[i:i+n]

        threads = []
        for query_lst in chunks_([i for i in reduce_kp], 10):
                for k, j in enumerate(query_lst):

                    thread1 = threading.Thread(target=func_list[k], args=(j[0] ,j[1]))
                    thread1.start()
                    threads.append(thread1)

                for thread in threads: thread.join()

响应是从线程调用的，即

def test_case(q_list):

        reduce_kp   = []
        for k in q_list: 
                reduce_kp.append([{'QTE':'EUR_USD'}, [k,'BAL'] ])
        multi_call(reduce_kp, test_case_resp)

线程化独立功能并等待它们完成

0 个答案: