マルチプロセッシングキューがPythonでどのように機能し、どのように実装するかを理解しようとすると、非常に苦労します。共有ファイルからデータにアクセスする2つのPythonモジュールがあるとしましょう。これらの2つのモジュールを、ライターとリーダーと呼びましょう。私の計画では、リーダーとライターの両方がリクエストを2つの別々のマルチプロセッシングキューに入れ、3番目のプロセスがこれらのリクエストをループでポップしてそのように実行するようにします。
私の主な問題は、multiprocessing.queueを正しく実装する方法が本当にわからないことです。プロセスごとにオブジェクトが個別のキューになるため、実際にインスタンス化することはできません。すべてのプロセスが共有キューに関連していることをどのように確認しますか（またはこの場合、キュー）
回答:
私の主な問題は、multiprocessing.queueを正しく実装する方法が本当にわからないことです。プロセスごとにオブジェクトが個別のキューになるため、実際にインスタンス化することはできません。すべてのプロセスが共有キューに関連していることをどのように確認しますか（またはこの場合、キュー）
これは、単一のキューを共有するリーダーとライターの簡単な例です...ライターは一連の整数をリーダーに送信します。ライターが数を使い果たすと、「DONE」を送信します。これにより、リーダーは読み取りループから抜け出すことができます。
from multiprocessing import Process, Queue
import time
import sys
def reader_proc(queue):
## Read from the queue; this will be spawned as a separate Process
while True:
msg = queue.get() # Read from the queue and do nothing
if (msg == 'DONE'):
break
def writer(count, queue):
## Write to the queue
for ii in range(0, count):
queue.put(ii) # Write 'count' numbers into the queue
queue.put('DONE')
if __name__=='__main__':
pqueue = Queue() # writer() writes to pqueue from _this_ process
for count in [10**4, 10**5, 10**6]:
### reader_proc() reads from pqueue as a separate process
reader_p = Process(target=reader_proc, args=((pqueue),))
reader_p.daemon = True
reader_p.start() # Launch reader_proc() as a separate python process
_start = time.time()
writer(count, pqueue) # Send a lot of stuff to reader()
reader_p.join() # Wait for the reader to finish
print("Sending {0} numbers to Queue() took {1} seconds".format(count,
(time.time() - _start)))
" from queue import Queue"には、と呼ばれるモジュールはありません。queue代わりmultiprocessingに使用する必要があります。したがって、「from multiprocessing import Queue」のようになります。
multiprocessing.Queueは正しいです。法線Queue.QueueはPythonスレッドに使用されます。Queue.Queueマルチプロセッシングで使用しようとすると、キューオブジェクトのコピーが各子プロセスで作成され、子プロセスが更新されることはありません。基本的に、Queue.Queueグローバル共有オブジェクトmultiprocessing.Queueを使用して機能し、IPCを使用して機能します。参照：stackoverflow.com/questions/925100/...
これは、の非常に単純な使用法でmultiprocessing.Queueありmultiprocessing.Process、呼び出し元が「イベント」と引数を別のプロセスに送信して、プロセスの「do_」メソッドにイベントをディスパッチできるようにします。（Python 3.4以降）
import multiprocessing as mp
import collections
Msg = collections.namedtuple('Msg', ['event', 'args'])
class BaseProcess(mp.Process):
"""A process backed by an internal queue for simple one-way message passing.
"""
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.queue = mp.Queue()
def send(self, event, *args):
"""Puts the event and args as a `Msg` on the queue
"""
msg = Msg(event, args)
self.queue.put(msg)
def dispatch(self, msg):
event, args = msg
handler = getattr(self, "do_%s" % event, None)
if not handler:
raise NotImplementedError("Process has no handler for [%s]" % event)
handler(*args)
def run(self):
while True:
msg = self.queue.get()
self.dispatch(msg)
使用法：
class MyProcess(BaseProcess):
def do_helloworld(self, arg1, arg2):
print(arg1, arg2)
if __name__ == "__main__":
process = MyProcess()
process.start()
process.send('helloworld', 'hello', 'world')
send、親プロセスで発生したdo_*子プロセスで起こります。
明らかに実行ループを中断して子プロセスを終了する例外処理を省略しました。オーバーライドrunしてブロッキングなどを制御することでカスタマイズすることもできます。
これは、実際には単一のワーカープロセスがある状況でのみ役立ちますが、もう少しオブジェクト指向の一般的なシナリオを示すことは、この質問に対する適切な答えだと思います。
大きなパンダのデータフレームを渡すためにキューを使用してマルチプロセッシングを実行する方法を設定しようとしているときに、スタックオーバーフローとWeb全体にわたる複数の回答を調べました。このような計算を設定するときに必ず遭遇する多数のエッジケースを考慮せずに、すべての回答が同じ種類のソリューションを繰り返しているように見えました。問題は、同時に多くのことが行われていることです。タスクの数、ワーカーの数、各タスクの期間、およびタスク実行中に発生する可能性のある例外。これらはすべて同期をトリッキーにし、ほとんどの回答は同期をどのように行うことができるかを扱っていません。ですから、これは数時間いじった後の私の見解です。うまくいけば、これはほとんどの人がそれが役立つと思うのに十分一般的であるでしょう。
コーディング例の前のいくつかの考え。以降queue.Emptyまたはqueue.qsize()または任意の他の同様の方法は、のような任意のコードフロー制御のために信頼できません
while True:
try:
task = pending_queue.get_nowait()
except queue.Empty:
break
偽物です。これにより、数ミリ秒後に別のタスクがキューに表示された場合でも、ワーカーが強制終了されます。ワーカーは回復せず、しばらくすると、キューが一時的に空になっていることがランダムに見つかるため、すべてのワーカーが消えます。最終的な結果として、メインのマルチプロセッシング関数（プロセスにjoin（）がある関数）は、すべてのタスクが完了せずに返されます。いいね。何千ものタスクがあり、いくつかが欠落している場合は、それを介してデバッグを頑張ってください。
もう1つの問題は、番兵値の使用です。多くの人が、キューの終わりにフラグを立てるために、キューに番兵の値を追加することを提案しています。しかし、正確に誰にフラグを立てるには？N個のワーカーが存在する場合、Nがギブまたはテイクで使用可能なコアの数であるとすると、単一の番兵値は1人のワーカーに対してキューの終わりにフラグを立てるだけです。他のすべての労働者は、何も残っていないときに、さらなる仕事を待って座っています。私が見た典型的な例は
while True:
task = pending_queue.get()
if task == SOME_SENTINEL_VALUE:
break
1人の労働者は番兵の値を取得し、残りの労働者は無期限に待機します。私が出くわした投稿では、すべてのワーカーがそれを取得できるように、少なくともワーカーの数だけ番兵の値をキューに送信する必要があると述べていません。
もう1つの問題は、タスク実行中の例外の処理です。繰り返しますが、これらはキャッチして管理する必要があります。さらに、completed_tasksキューがある場合は、ジョブが完了したと判断する前に、キューにあるアイテムの数を決定論的な方法で個別にカウントする必要があります。この場合も、キューサイズに依存すると失敗し、予期しない結果が返されます。
以下の例では、par_proc()関数は、名前付き引数および値とともに、これらのタスクを実行する必要がある関数を含むタスクのリストを受け取ります。
import multiprocessing as mp
import dill as pickle
import queue
import time
import psutil
SENTINEL = None
def do_work(tasks_pending, tasks_completed):
# Get the current worker's name
worker_name = mp.current_process().name
while True:
try:
task = tasks_pending.get_nowait()
except queue.Empty:
print(worker_name + ' found an empty queue. Sleeping for a while before checking again...')
time.sleep(0.01)
else:
try:
if task == SENTINEL:
print(worker_name + ' no more work left to be done. Exiting...')
break
print(worker_name + ' received some work... ')
time_start = time.perf_counter()
work_func = pickle.loads(task['func'])
result = work_func(**task['task'])
tasks_completed.put({work_func.__name__: result})
time_end = time.perf_counter() - time_start
print(worker_name + ' done in {} seconds'.format(round(time_end, 5)))
except Exception as e:
print(worker_name + ' task failed. ' + str(e))
tasks_completed.put({work_func.__name__: None})
def par_proc(job_list, num_cpus=None):
# Get the number of cores
if not num_cpus:
num_cpus = psutil.cpu_count(logical=False)
print('* Parallel processing')
print('* Running on {} cores'.format(num_cpus))
# Set-up the queues for sending and receiving data to/from the workers
tasks_pending = mp.Queue()
tasks_completed = mp.Queue()
# Gather processes and results here
processes = []
results = []
# Count tasks
num_tasks = 0
# Add the tasks to the queue
for job in job_list:
for task in job['tasks']:
expanded_job = {}
num_tasks = num_tasks + 1
expanded_job.update({'func': pickle.dumps(job['func'])})
expanded_job.update({'task': task})
tasks_pending.put(expanded_job)
# Use as many workers as there are cores (usually chokes the system so better use less)
num_workers = num_cpus
# We need as many sentinels as there are worker processes so that ALL processes exit when there is no more
# work left to be done.
for c in range(num_workers):
tasks_pending.put(SENTINEL)
print('* Number of tasks: {}'.format(num_tasks))
# Set-up and start the workers
for c in range(num_workers):
p = mp.Process(target=do_work, args=(tasks_pending, tasks_completed))
p.name = 'worker' + str(c)
processes.append(p)
p.start()
# Gather the results
completed_tasks_counter = 0
while completed_tasks_counter < num_tasks:
results.append(tasks_completed.get())
completed_tasks_counter = completed_tasks_counter + 1
for p in processes:
p.join()
return results
そして、これは上記のコードを実行するためのテストです
def test_parallel_processing():
def heavy_duty1(arg1, arg2, arg3):
return arg1 + arg2 + arg3
def heavy_duty2(arg1, arg2, arg3):
return arg1 * arg2 * arg3
task_list = [
{'func': heavy_duty1, 'tasks': [{'arg1': 1, 'arg2': 2, 'arg3': 3}, {'arg1': 1, 'arg2': 3, 'arg3': 5}]},
{'func': heavy_duty2, 'tasks': [{'arg1': 1, 'arg2': 2, 'arg3': 3}, {'arg1': 1, 'arg2': 3, 'arg3': 5}]},
]
results = par_proc(task_list)
job1 = sum([y for x in results if 'heavy_duty1' in x.keys() for y in list(x.values())])
job2 = sum([y for x in results if 'heavy_duty2' in x.keys() for y in list(x.values())])
assert job1 == 15
assert job2 == 21
プラスいくつかの例外を除いて別のもの
def test_parallel_processing_exceptions():
def heavy_duty1_raises(arg1, arg2, arg3):
raise ValueError('Exception raised')
return arg1 + arg2 + arg3
def heavy_duty2(arg1, arg2, arg3):
return arg1 * arg2 * arg3
task_list = [
{'func': heavy_duty1_raises, 'tasks': [{'arg1': 1, 'arg2': 2, 'arg3': 3}, {'arg1': 1, 'arg2': 3, 'arg3': 5}]},
{'func': heavy_duty2, 'tasks': [{'arg1': 1, 'arg2': 2, 'arg3': 3}, {'arg1': 1, 'arg2': 3, 'arg3': 5}]},
]
results = par_proc(task_list)
job1 = sum([y for x in results if 'heavy_duty1' in x.keys() for y in list(x.values())])
job2 = sum([y for x in results if 'heavy_duty2' in x.keys() for y in list(x.values())])
assert not job1
assert job2 == 21
お役に立てば幸いです。
これには2つのバージョンを実装しました。1つは多くの種類の呼び出し可能オブジェクトを実行できる単純なマルチスレッドプールで、私たちの生活をはるかに楽にします。もう1つはプロセスを使用するバージョンで、呼び出し可能で柔軟性が低く、dillへの追加の呼び出しが必要です。
フリーズプールをtrueに設定すると、いずれかのクラスでfinish_pool_queueが呼び出されるまで実行がフリーズします。
スレッドバージョン：
'''
Created on Nov 4, 2019
@author: Kevin
'''
from threading import Lock, Thread
from Queue import Queue
import traceback
from helium.loaders.loader_retailers import print_info
from time import sleep
import signal
import os
class ThreadPool(object):
def __init__(self, queue_threads, *args, **kwargs):
self.frozen_pool = kwargs.get('frozen_pool', False)
self.print_queue = kwargs.get('print_queue', True)
self.pool_results = []
self.lock = Lock()
self.queue_threads = queue_threads
self.queue = Queue()
self.threads = []
for i in range(self.queue_threads):
t = Thread(target=self.make_pool_call)
t.daemon = True
t.start()
self.threads.append(t)
def make_pool_call(self):
while True:
if self.frozen_pool:
#print '--> Queue is frozen'
sleep(1)
continue
item = self.queue.get()
if item is None:
break
call = item.get('call', None)
args = item.get('args', [])
kwargs = item.get('kwargs', {})
keep_results = item.get('keep_results', False)
try:
result = call(*args, **kwargs)
if keep_results:
self.lock.acquire()
self.pool_results.append((item, result))
self.lock.release()
except Exception as e:
self.lock.acquire()
print e
traceback.print_exc()
self.lock.release()
os.kill(os.getpid(), signal.SIGUSR1)
self.queue.task_done()
def finish_pool_queue(self):
self.frozen_pool = False
while self.queue.unfinished_tasks > 0:
if self.print_queue:
print_info('--> Thread pool... %s' % self.queue.unfinished_tasks)
sleep(5)
self.queue.join()
for i in range(self.queue_threads):
self.queue.put(None)
for t in self.threads:
t.join()
del self.threads[:]
def get_pool_results(self):
return self.pool_results
def clear_pool_results(self):
del self.pool_results[:]
プロセスバージョン：
'''
Created on Nov 4, 2019
@author: Kevin
'''
import traceback
from helium.loaders.loader_retailers import print_info
from time import sleep
import signal
import os
from multiprocessing import Queue, Process, Value, Array, JoinableQueue, Lock,\
RawArray, Manager
from dill import dill
import ctypes
from helium.misc.utils import ignore_exception
from mem_top import mem_top
import gc
class ProcessPool(object):
def __init__(self, queue_processes, *args, **kwargs):
self.frozen_pool = Value(ctypes.c_bool, kwargs.get('frozen_pool', False))
self.print_queue = kwargs.get('print_queue', True)
self.manager = Manager()
self.pool_results = self.manager.list()
self.queue_processes = queue_processes
self.queue = JoinableQueue()
self.processes = []
for i in range(self.queue_processes):
p = Process(target=self.make_pool_call)
p.start()
self.processes.append(p)
print 'Processes', self.queue_processes
def make_pool_call(self):
while True:
if self.frozen_pool.value:
sleep(1)
continue
item_pickled = self.queue.get()
if item_pickled is None:
#print '--> Ending'
self.queue.task_done()
break
item = dill.loads(item_pickled)
call = item.get('call', None)
args = item.get('args', [])
kwargs = item.get('kwargs', {})
keep_results = item.get('keep_results', False)
try:
result = call(*args, **kwargs)
if keep_results:
self.pool_results.append(dill.dumps((item, result)))
else:
del call, args, kwargs, keep_results, item, result
except Exception as e:
print e
traceback.print_exc()
os.kill(os.getpid(), signal.SIGUSR1)
self.queue.task_done()
def finish_pool_queue(self, callable=None):
self.frozen_pool.value = False
while self.queue._unfinished_tasks.get_value() > 0:
if self.print_queue:
print_info('--> Process pool... %s' % (self.queue._unfinished_tasks.get_value()))
if callable:
callable()
sleep(5)
for i in range(self.queue_processes):
self.queue.put(None)
self.queue.join()
self.queue.close()
for p in self.processes:
with ignore_exception: p.join(10)
with ignore_exception: p.terminate()
with ignore_exception: del self.processes[:]
def get_pool_results(self):
return self.pool_results
def clear_pool_results(self):
del self.pool_results[:]
def test(eg):
print 'EG', eg
次のいずれかで電話します。
tp = ThreadPool(queue_threads=2)
tp.queue.put({'call': test, 'args': [random.randint(0, 100)]})
tp.finish_pool_queue()
または
pp = ProcessPool(queue_processes=2)
pp.queue.put(dill.dumps({'call': test, 'args': [random.randint(0, 100)]}))
pp.queue.put(dill.dumps({'call': test, 'args': [random.randint(0, 100)]}))
pp.finish_pool_queue()
2つのスタンドアロンプログラム間でキューを介してメッセージを渡す方法を示すための簡単で一般的な例を作成しました。OPの質問に直接答えることはありませんが、概念を示すのに十分明確である必要があります。
サーバ：
multiprocessing-queue-manager-server.py
import asyncio
import concurrent.futures
import multiprocessing
import multiprocessing.managers
import queue
import sys
import threading
from typing import Any, AnyStr, Dict, Union
class QueueManager(multiprocessing.managers.BaseManager):
def get_queue(self, ident: Union[AnyStr, int, type(None)] = None) -> multiprocessing.Queue:
pass
def get_queue(ident: Union[AnyStr, int, type(None)] = None) -> multiprocessing.Queue:
global q
if not ident in q:
q[ident] = multiprocessing.Queue()
return q[ident]
q: Dict[Union[AnyStr, int, type(None)], multiprocessing.Queue] = dict()
delattr(QueueManager, 'get_queue')
def init_queue_manager_server():
if not hasattr(QueueManager, 'get_queue'):
QueueManager.register('get_queue', get_queue)
def serve(no: int, term_ev: threading.Event):
manager: QueueManager
with QueueManager(authkey=QueueManager.__name__.encode()) as manager:
print(f"Server address {no}: {manager.address}")
while not term_ev.is_set():
try:
item: Any = manager.get_queue().get(timeout=0.1)
print(f"Client {no}: {item} from {manager.address}")
except queue.Empty:
continue
async def main(n: int):
init_queue_manager_server()
term_ev: threading.Event = threading.Event()
executor: concurrent.futures.ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor()
i: int
for i in range(n):
asyncio.ensure_future(asyncio.get_running_loop().run_in_executor(executor, serve, i, term_ev))
# Gracefully shut down
try:
await asyncio.get_running_loop().create_future()
except asyncio.CancelledError:
term_ev.set()
executor.shutdown()
raise
if __name__ == '__main__':
asyncio.run(main(int(sys.argv[1])))
クライアント：
multiprocessing-queue-manager-client.py
import multiprocessing
import multiprocessing.managers
import os
import sys
from typing import AnyStr, Union
class QueueManager(multiprocessing.managers.BaseManager):
def get_queue(self, ident: Union[AnyStr, int, type(None)] = None) -> multiprocessing.Queue:
pass
delattr(QueueManager, 'get_queue')
def init_queue_manager_client():
if not hasattr(QueueManager, 'get_queue'):
QueueManager.register('get_queue')
def main():
init_queue_manager_client()
manager: QueueManager = QueueManager(sys.argv[1], authkey=QueueManager.__name__.encode())
manager.connect()
message = f"A message from {os.getpid()}"
print(f"Message to send: {message}")
manager.get_queue().put(message)
if __name__ == '__main__':
main()
使用法
サーバ：
$ python3 multiprocessing-queue-manager-server.py N
N作成するサーバーの数を示す整数です。<server-address-N>サーバーによる出力の1つをコピーし、それを各の最初の引数にしますmultiprocessing-queue-manager-client.py。
クライアント：
python3 multiprocessing-queue-manager-client.py <server-address-1>
結果
サーバ：
Client 1: <item> from <server-address-1>
要旨：https：//gist.github.com/89062d639e40110c61c2f88018a8b0e5
サーバ：
import ipcq
with ipcq.QueueManagerServer(address=ipcq.Address.DEFAULT, authkey=ipcq.AuthKey.DEFAULT) as server:
server.get_queue().get()
クライアント：
import ipcq
client = ipcq.QueueManagerClient(address=ipcq.Address.DEFAULT, authkey=ipcq.AuthKey.DEFAULT)
client.get_queue().put('a message')
