Sincronización y poolización de procesos en Python

Sincronización entre flujos

El procesamiento múltiple es un paquete que admite la generación de programas utilizando API. Este paquete se utiliza para la concurrencia local y remota. Utilizando este módulo, los programadores pueden utilizar múltiples procesadores en el ordenador dado. Puede ejecutarse en sistemas operativos Windows y UNIX.

Este paquete contiene todos los sinónimos de los primitivos de sincronización.

Ejemplo　de　código

from multiprocessing import Process, Lock
　　　def mi_funcion(x, y):
　　　　　　x.acquire()
　　　　　　imprime('hola mundo', y)
　　　　　　x.release()
　　　　　　if　__name__　==　'__main__':
　　　　　　lock = Lock() for num in range(10)
Process(target=my_function, args=(lock, num)).start()

Aquí, una instancia puede bloquearse para asegurar que solo un proceso pueda mostrar la salida estándar a la vez.

reunir

Para el pool, usamos la clase Pool. Cuando alguien crea un pool de procesos, llevará todas las tareas que se le envíen.

class multiprocessing.Pool([processes[, initializer[, initargs[, maxtasksperchild]]]])

El objeto de pool controla el pool de trabajo para seleccionar las tareas que se pueden enviar, admite resultados asíncronos con tiempo de espera, devolución de llamada y mapeo paralelo.

si el proceso está vacío, se usa cpu_count(); si se inicializa en none, se usa initializer (* al llamar a esta función. initargs)

apply(func[, args[, kwds]])

esto es equivalente aapply()función integrada similar. Este método se bloqueará hasta que los resultados estén listos, por lo que apply_async() es mejor para la ejecución paralela.

apply_async(func[, args[, kwds[, callback]]])

devuelve un objeto de resultados.

map(func, iterable[，chunksize] )

map() es una función integrada que solo admite un parámetro iterable. Bloqueará hasta que los resultados estén listos.

En este método, el iterable se descompone en muchos trozos y estos trozos se envían como tareas individuales al pool de procesos.

map_async(func, iterable [，chunksize [，callback]] )

devuelve un objeto de resultados.

imap(func, iterable [，chunksize] )

igual que itertools.imap().

el tamaño del parámetro es el mismo que el utilizadomap().

imap_unordered(func, iterable [，chunksize] )

esto es equivalente aimap()ajustar nuevamente el orden del iterador.

cerrar()

el trabajador saldrá del flujo una vez que complete todas las tareas.

terminar()

Si queremos detener inmediatamente el proceso de trabajo sin completar la tarea, use este método.

unir()

al usarjoin()antes de usarclose()yterminate()función.

clase multiprocessing.pool.AsyncResult

Devuelto　por　Pool.apply_async()　y　Pool.map_async()

Get（[tiempo de espera]）

Esta　función　devuelve　el　resultado　al　llegar。

Esperar（[tiempo de espera]）

Usando　esta　función　de　espera,　esperamos　hasta　que　el　resultado　esté　disponible　o　hasta　que　pasen　los　segundos de　tiempo

Preparar()

Esta　función　devuelve　si　la　llamada　se　completó。

Éxito()

No　hay　ningún　error　al　completar　la　llamada,　esta　función　devolverá。

Ejemplo　de　código

#　-*-　coding:　utf-8　-*-
"""
Creado　el　Dom　Sep　30　12:17:58　2018
@author:　oldtoolbag.com
"""
from　multiprocessing　import　Pool
import　time
def　myfunction(m):
return　m*m
if　__name__　==　'__main__':
my_pool　=　Pool(processes=4)　#　iniciar　4　procesos　trabajadores
result　=　my_pool.apply_async(myfunction,　(10,))　#　evaluar　"f(10))"　asíncronamente　en　un　único　proceso
print　(result.get(timeout=1))
print　(my_pool.map(myfunction,　range(10))　#　imprime　"[0,　1,　4,...,　81]"
my_it　=　my_pool.imap(myfunction,　range(10))
print　(my_it.next()　)　#　imprime　"0"
print　(my_it.next()　)　#　imprime　"1"
print　(my_it.next(timeout=1)　)　#　imprime　"4"　a menos que　tu　computadora　sea　*muy*　lento
result　=　my_pool.apply_async(time.sleep,　(10,))
print　(result.get(timeout=1)　)　#　lleva　a　la　excepción　multiprocessing.TimeoutError