python - pyplot - symbols in matplotlib

Python enhebra múltiples subprocesos bash?

Question

¿Cómo se usan los módulos de subproceso y subprocesamiento para generar procesos de bash paralelos? Cuando inicio los hilos, la primera respuesta aquí es: ¿Cómo usar threading en Python? , los procesos bash se ejecutan secuencialmente en lugar de en paralelo.

Answer 1

No necesita hilos para ejecutar subprocesos en paralelo:

from subprocess import Popen
commands = [
''date; ls -l; sleep 1; date'',
''date; sleep 5; date'',
''date; df -h; sleep 3; date'',
''date; hostname; sleep 2; date'',
''date; uname -a; date'',
]
# run in parallel
processes = [Popen(cmd, shell=True) for cmd in commands]
# do other things here..
# wait for completion
for p in processes: p.wait()

Para limitar el número de comandos simultáneos, puede usar multiprocessing.dummy.Pool que usa subprocesos y proporciona la misma interfaz que multiprocessing.Pool que usa procesos:

from functools import partial
from multiprocessing.dummy import Pool
from subprocess import call
pool = Pool(2) # two concurrent commands at a time
for i, returncode in enumerate(pool.imap(partial(call, shell=True), commands)):
if returncode != 0:
print("%d command failed: %d" % (i, returncode))

Esta respuesta muestra varias técnicas para limitar el número de subprocesos concurrentes : muestra multiprocesamiento. Pool, concurrent.futures, threading + soluciones basadas en Queue.

Puede limitar el número de procesos secundarios concurrentes sin usar un grupo de subprocesos / procesos:

from subprocess import Popen
from itertools import islice
max_workers = 2 # no more than 2 concurrent processes
processes = (Popen(cmd, shell=True) for cmd in commands)
running_processes = list(islice(processes, max_workers)) # start new processes
while running_processes:
for i, process in enumerate(running_processes):
if process.poll() is not None: # the process has finished
running_processes[i] = next(processes, None) # start new process
if running_processes[i] is None: # no new processes
del running_processes[i]
break

En Unix, puede evitar el ciclo ocupado y bloquear en os.waitpid(-1, 0) , para esperar a que salga cualquier proceso hijo .

Answer 2

Un simple ejemplo de subprocesamiento:

import threading
import Queue
import commands
import time
# thread class to run a command
class ExampleThread(threading.Thread):
def __init__(self, cmd, queue):
threading.Thread.__init__(self)
self.cmd = cmd
self.queue = queue
def run(self):
# execute the command, queue the result
(status, output) = commands.getstatusoutput(self.cmd)
self.queue.put((self.cmd, output, status))
# queue where results are placed
result_queue = Queue.Queue()
# define the commands to be run in parallel, run them
cmds = [''date; ls -l; sleep 1; date'',
''date; sleep 5; date'',
''date; df -h; sleep 3; date'',
''date; hostname; sleep 2; date'',
''date; uname -a; date'',
]
for cmd in cmds:
thread = ExampleThread(cmd, result_queue)
thread.start()
# print results as we get them
while threading.active_count() > 1 or not result_queue.empty():
while not result_queue.empty():
(cmd, output, status) = result_queue.get()
print(''%s:'' % cmd)
print(output)
print(''=''*60)
time.sleep(1)

Tenga en cuenta que hay mejores formas de hacer algo de esto, pero esto no es demasiado complicado. El ejemplo usa un hilo para cada comando. La complejidad comienza a aparecer cuando desea hacer cosas como usar un número limitado de subprocesos para manejar una cantidad desconocida de comandos. Esas técnicas más avanzadas no parecen demasiado complicadas una vez que tienes un conocimiento básico de threading. Y el multiprocesamiento se vuelve más fácil una vez que maneja esas técnicas.

Answer 3

esto es porque se supone que tiene que hacer, lo que quieres hacer no es multiproceso sino multiprocesamiento ver esta página de pila