El modelo de consumidor productor de ayer realmente no me escuchó mucho, porque estaba demasiado ocupado para consumir hace unos días y anoche tenía demasiado sueño. Muchas computadoras me destrozaron la cara, así que hoy hablaré sobre el modelo de consumidor productor en detalle.
Se trata principalmente de utilizar la cola para darse cuenta de la conexión entre un productor y un consumidor. De hecho, ha utilizado una lista para lograrlo antes, pero obviamente esa forma es muy inapropiada. La conexión entre el productor y el consumidor es demasiado fuerte. Todos comienzan a comer después de la producción, o comen mientras producen, lo que no refleja la relación aleatoria entre productores y consumidores.
La siguiente versión debería ser la inicial, al juzgar si la cola q está vacía, el consumidor y el productor se ponen en contacto:
importar aleatorio, cola, tiempo importar subprocesos q = cola.Queue () def product (name): count = 0 while count <10 : print ( ' % s is making. ' % name) time.sleep (random.randrange ( 3) )) q.put (str (count) + ' baozi ' ) print ( ' % s había hecho No.% s baozi ' % (name, count)) count + = 1 def consumidor (nombre): cuenta = 0 # print (q.empty ()) mientras cuenta <10 : si q.empty (): data = q.get () print ( ' \ 033 [32;% s está comiendo% s \ 033 [0m ' % (nombre, datos)) time.sleep (random.randrange ( 4 )) else : print ( ' no baozi more ' ) print ( ' waiting ' ) count + = 1 if __name__ == ' __main__ ' : t1 = threading.Thread (target = product, args = ( ' zhaolei ' ,)) t2 = threading.Thread (target = consumer, args = ( ' zjl ' ,)) t3 = threading. Thread (target = consumer, args = ( ' mayday ' ,)) t4 = threading.Thread (target = consumer, args = ( ' golo ' ,)) t1.start () t2.start () t3.start () t4 .comienzo()
Lo anterior es un cierto acoplamiento, pero no es muy obvio. Ayer dijimos q.join () y q.task_done ()
Cuando se completa una cola, q.task_done () liberará la señal y será recibida por q.join (). Si no se recibe información, el hilo esperará en q.join () hasta que se reciba. Arriba lo logramos a través de q.empty (), desbloqueemos la nueva situación
importar aleatorio, cola, tiempo importar subprocesos q = cola.Queue () def product (name): count = 0 while count <10 : print ( ' % s is making. ' % name) time.sleep (random.randrange ( 3 )) q.put (str (count) + ' baozi ' ) print ( ' % s había hecho No.% s baozi ' % (name, count)) q.task_done () count + = 1 def consumer (name): count = 0 while count <10 : print ( ' % s está esperando ' % name) q.join () data = q.get () print ( ' \ 033 [32;% s está comiendo% s \ 033 [0m ' % (nombre, datos)) time.sleep (random.randrange ( 2 )) # print (q.empty ()) if __name__ == ' __main__ ' : t1 = threading.Thread (target = product , args = (' zhaolei ' ,)) t2 = threading.Thread (target = consumer, args = ( ' zjl ' ,)) t3 = threading.Thread (target = consumer, args = ( ' mayday ' ,)) t4 = threading.Thread ( target = consumidor, args = ( ' golo ' ,)) t1.start () t2.start () t3.start () t4.start ()
Al mismo tiempo, la interacción de información entre q.join () y q.task_done () también se puede utilizar a la inversa, es solo que después de que el cliente termine de comer una, el jefe continuará haciéndolo.
Lo anterior es la parte multiproceso, lo siguiente ingresa a la parte multiproceso
Para compensar el arrepentimiento de no poder utilizar los beneficios de las computadoras de múltiples núcleos, Python introdujo el concepto de un proceso de configuración, que es GIL múltiple, que maximiza el uso de recursos
Dicho profesionalmente: debido a la existencia de GIL, los subprocesos múltiples en Python no son realmente subprocesos múltiples. Si desea utilizar por completo los recursos de las CPU de varios núcleos, en la mayoría de los casos en Python, debe usar multiprocesos.
El paquete de multiprocesamiento es un paquete de gestión multiproceso en Python. Similar a threading.Thread, puede usar el objeto multiprocessing.Process para crear un proceso. Este proceso puede ejecutar funciones escritas dentro de los programas Python. El objeto Process tiene el mismo uso que el objeto Thread, y también tiene métodos start (), run (), join (). Además, el paquete Multiprocesamiento también tiene la clase Lock / Event / Semaphore / Condition (estos objetos se pueden pasar a cada proceso a través de parámetros como multi-threading) para sincronizar procesos, y su uso es consistente con la clase del mismo nombre en el paquete de threading. Por lo tanto, una gran parte del multiprocesamiento usa la misma API que el subproceso, pero solo en el contexto de multiproceso.
Primero mire el método de llamada de multiproceso:
de multiprocesamiento importación Proceso de importación tiempo def f (nombre): time.sleep ( 1 ) de impresión ( ' hola ' , nombre, time.ctime ()) si __name__ == ' __main__ ' : p_list = [] para i en alcance (3 ): p = Proceso (target = f, args = ( ' alvin ' ,)) p_list.append (p) p.start () para i en p_list: p.join () print ( ' fin ' )
Método 2:
desde el proceso de importación multiprocesamiento Clase de tiempo de importación de proceso MyProcess (Proceso): def __init__ (self): super (MyProcess, self). __init__ () # self.name = name def run (self): time.sleep ( 1 ) print ( ' hello ' , self.name, time.ctime ()) if __name__ == ' __main__ ' : p_list = [] para i en rango (3 ): p = MyProcess () p.start () p_list.append (p) para p en p_list: p.join () print ( ' fin ' )
En términos de método de llamada, es básicamente similar a multi-threading
Luego hay algunas propiedades reales de esta clase:
Método de construcción:
Proceso ([grupo [, destino [, nombre [, args [, kwargs]]]]])
group: grupo de subprocesos, que aún no se ha implementado, la sugerencia en la referencia de la biblioteca debe ser None;
target: el método a ejecutar;
nombre: nombre del proceso;
args / kwargs: los parámetros que se pasarán al método.
Método de ejemplo:
is_alive (): Devuelve si el proceso se está ejecutando.
join ([timeout]): bloquea el proceso del contexto actual hasta que el proceso que llama a este método finaliza o alcanza el tiempo de espera especificado (parámetro opcional).
start (): el proceso está listo, esperando la programación de la CPU
run (): strat () llama al método run. Si el proceso de la instancia no especifica un objetivo entrante, esta estrella ejecuta el método run () predeterminado.
terminar (): independientemente de si la tarea se ha completado, detenga inmediatamente el proceso de trabajo
Propiedades:
daemon: misma función que el setDeamon de thread
nombre: nombre del proceso.
pid: número de proceso.
getpid: obtiene el número de proceso.
getppid: obtiene el número de proceso del proceso padre.
El contenido de hoy es todo eso. No recuerdo el conocimiento de la parte del zócalo, así que después de actualizar la semana multiproceso mañana, planeo volver a revisar el conocimiento. Es solo la próxima semana que iré a investigar a una persona muy importante.
Para dormir normalmente esta noche, ve a un corte de pelo mañana.