在流程之間共享不斷變化的詞典

Question

問題陳述

我面臨多處理問題。 多處理堆棧溢出問題的很大一部分沒有我的情況復雜，也沒有回答它。 有些人投票說這個問題可能重復，但我的情況有所不同，在我的情況下，共享DICT在進程之間被修改了：

我有一個程序遵循這個簡化的生命周期：

A. Initialize DATA dict
B. Initialize 4 subprocess workers
C. Execute code in each workers (worker massively read DATA dict)
D. Wait workers job is done
E. Modify DATA dict content
F. Go to C

性能是問題的一個非常重要的方面。 我嘗試了許多正面和負面的解決方案：

簡單的全球字典（不工作）

在步驟B ， DICT變量被分叉到子進程環境中。 但是在步驟E子流程無法看到變化。

使用multiprocessing.Manager dict

在步驟A使用multiprocessing.Manager創建dict（請參閱此處的 “服務器進程”）。

• 優點 ：易於使用
• 缺點 ： multiprocessing.Manager使用序列化層（我不太了解它，但它能夠與網絡上的進程一起工作），這對性能有害。

使用多個multiprocessing.Value和multiprocessing.Array而不是dict

multiprocessing.Value和multiprocessing.Array允許使用共享內存。 我試圖用幾個multiprocessing.Value和multiprocessing.Array替換我的dict.Array像這樣：

用dict：

manager = multiprocessing.Manager()
dict = manager.dict()
dict['positions'] = [42, 165]
dict['on_position_42'] = 1555897
dict['on_position_165'] = 1548792

用multiprocessing.Value multiprocessing.Array代替dict.Value和multiprocessing.Array ：

positions = multiprocessing.Array('i', [42, 165])
on_position_42 = multiprocessing.Value('i', 1555897)
on_position_165 = multiprocessing.Value('i', 1548792)

但是在步驟E我將需要創建新的multiprocessing.Value和multiprocessing.Array ，例如：

positions.value = [42, 165, 322]
# create new multiprocessing.Value for 322
on_position_322 = multiprocessing.Value('i', 2258777)

然后在步驟C ， on_position_322將不知道on_position_322 。 如果我嘗試發送multiprocessing.Value或multiprocessing.Array通過管道子進程，將導致“同步對象應該只通過繼承在進程之間共享”錯誤。

• 優點 ：表現
• 缺點 ：如何“通知”子進程有關新的multiprocessing.Value multiprocessing.Array存在。值和multiprocessing.Array ？

使用內存數據庫，如memcache或redis

我知道這是一種可能性，但我必須對內存數據庫與multiprocessing.Manager對比。 multiprocessing.Manager dict。

• 優點 ：務實和工作
• 缺點 ：表現？

問題結論

是否存在使用multiprocessing.Value和multiprocessing.Array在這個生命周期中，考慮創建新的multiprocessing.Value和multiprocessing.Array ？

或者更一般地說，考慮到這個生命周期，最有效的策略是什么？

注意 ：我之前嘗試過另一種策略，其中步驟F是“轉到B”（在每個周期重新創建新工人）。 但工人的分岔環境太長了：最大的是DICT最長的是叉子。

Answer 1

由於您只是從字典中讀取並在主過程中更新它，因此您可以使用JoinableQueue傳遞字典並等待工作人員完成。 例如

from multiprocessing import Process, JoinableQueue
import time

class Worker(Process):
    def __init__(self, queue):
        super(Worker, self).__init__()
        self.queue = queue

    def run(self):
        for item in iter(self.queue.get, None):
            print item
            time.sleep(2)
            print 'done'
            self.queue.task_done()
        self.queue.task_done()

if __name__ == '__main__':
    request_queue = JoinableQueue()
    num_workers = 4
    workers = []
    d = {}  # A

    for _ in range(num_workers): 
        p = Worker(request_queue) # B
        workers.append(p)
        p.start()


    for i in range(5): # F
        for _ in range(num_workers):
            request_queue.put(d) # C
        request_queue.join()  # D
        d[i] = i  # E

    for w in workers:
        w.terminate()
        w.join()

輸出：

{}
{}
{}
{}
done
done
done
done
{0: 0}
{0: 0}
{0: 0}
{0: 0}
done
done
done
done
{0: 0, 1: 1}
{0: 0, 1: 1}
{0: 0, 1: 1}
{0: 0, 1: 1}
done
done
done
done
{0: 0, 1: 1, 2: 2}
{0: 0, 1: 1, 2: 2}
{0: 0, 1: 1, 2: 2}
{0: 0, 1: 1, 2: 2}
done
done
done
done
{0: 0, 1: 1, 2: 2, 3: 3}
{0: 0, 1: 1, 2: 2, 3: 3}
{0: 0, 1: 1, 2: 2, 3: 3}
{0: 0, 1: 1, 2: 2, 3: 3}
done
done
done
done