A, Proceso
parámetros introdujo:
. 1 parámetro de grupo no se usa, el valor es siempre Ninguna
muestra objeto llamada 2 diana, es decir, la tarea de sub-proceso que se lleva a cabo
3 args parámetro indica la posición del objeto llamada tupla, args = (1,2, 'A ' ,)
4 representa un kwargs diccionario de objetos llamada, kwargs =. { 'nombre': 'a', 'Age': 18 es}
5 nombre subproceso es el nombre de.
el método descrito:
. 1 p.start (): proceso de comenzar, y llama a la p.run el proceso hijo ()
2 p.run (): método de operación, cuando se inicia el proceso, que es la función para llamar al destino especificado, podemos aduana clases debe lograrse mediante el método
p.terminate 3 ( ): p obligado a terminar el proceso, no va a llevar a cabo cualquier operación de limpieza, si p crear un proceso hijo, el proceso hijo se convierta en un proceso zombie, este método requiere un cuidado especial esta situación. Si p entonces también salvó, no se dará a conocer una cerradura, lo que lleva a un callejón sin salida
p.is_alive 4 (): Si p se sigue ejecutando y devuelve verdadero
5 p.join ([Tiempo de espera]): p espera para el hilo principal para terminar (énfasis en : es el hilo principal en el estado, etc., y p está en un estado de funcionamiento). tiempo de espera es el tiempo de espera opcional Debe subrayarse que, p.join puede unirse vivo iniciar proceso abierto, y no puede unirse a plazo en directo para abrir el proceso de
la propiedad Descripción:
1 p.daemon: El valor predeterminado es Falso, Si es verdadero , p es representativa del demonio que se ejecuta en segundo plano, cuando la terminación del proceso padre p, p también se dará por terminado y se establece en True después, p no puede crear su propio nuevo proceso debe ser () set antes p.start
2 p .name: nombre del proceso
3 p.pid: PID de proceso
4 p.exitcode: Ninguno en el proceso se está ejecutando, si -N, que representa el final de la señal N (a entienda)
5 p.authkey: el proceso de clave de autenticación, por el sistema operativo predeterminado .urandom () cadena de 32 caracteres generados aleatoriamente. Utilizar la clave es garantizar la seguridad de la conexión de red entre los procesos subyacentes involucrados en la comunicación, este tipo de conexión sólo cuando tienen la misma clave de autenticación para el éxito (entender)
1, la unión: proceso espera de los padres para que el proceso hijo comienzan antes del final de la propias de ejecución de código
# envían un mensaje
de importación Tiempo
de importación aleatoria
de multiprocesamiento proceso de importación
DEF FUNC ():
retraso time.sleep (random.randint (1,3)) # analógico enviado mensajes
de impresión ( 'mensaje ha sido enviado')
SI == __name__ '__main__':
p = proceso (target = FUNC)
p.start ()
p.join () # bloque hasta que el proceso se haya completado antes del final de la aplicación p bloqueado
print ( 'mensaje ha sido enviado')
# enviar diez electrónico
de importación tiempo
de importación aleatoria
de multiprocesamiento proceso de importación
DEF FUNC (índice):
la time.sleep (la random.randint (l, 3))
de impresión ( '% s de mensajes ha sido enviado' index%)
SI el __name__ == '__main__':
p_lst = []
para I en el rango de (10):
P = Proceso (target = Func, args = (i,))
p.start () # permiten todos los sub-procesos son hasta
p_lst.append (p-)
para la p-en p_lst: # y luego se unen bloqueado
p.join ()
Imprimir ('10 se han recibido mensajes ')
2, proceso abierto con el tipo de camino
cuando creamos un proceso antes de crear realmente un objeto de la clase de proceso, y luego llamar proceso abierto método start del objeto,
entonces podemos ser su propia definición de una clase crear un proceso de aplicación:
import os
de multiprocesamiento importación proceso
MyProcess clase (proceso): # define una clase que hereda la clase proceso de
definición de gestión (self): # los métodos deben ser implementadas, es para iniciar el proceso de método
de impresión ( 'proceso hijo:', os.getpid (), os.getppid ())
SI el __name__ == '__principal__':
p = MyProcess () # instancia
p.start () # llamará automáticamente al método run
de impresión ( 'padre:', os.getpid ())
a la clase personalizada paso de parámetros:
Primer vistazo fuente de Proceso
Importación Tiempo
de importación OS
de multiprocesamiento importación Proceso
MyProcess clase (Proceso):
DEF la __init __ (self, I):
super () .__ init __ () # implementar inicialización métodos de la clase padre
self.index = i # define sus propios atributos (parámetros)
DEF RUN (Self):
la time.sleep (1.)
Imprimir ( 'sub-proceso:', self.index, os.getpid (), os.getppid ())
SI el __name__ == '__main__':
p_lst = []
para I en Rango (10):
P = MyProcess (I)
p.start ()
p_lst.append (P)
para P en p_lst:
p.join ()
Imprimir ( 'proceso primario:', os.getpid ())
. 3, daemon
crear un proceso daemon maestro
1: daemon terminará después del final de la ejecución de código principal proceso de
2: En demonio no puede convertir a un proceso hijo, de lo contrario, se produce una excepción: AssertionError: procesos daemonic no se les permite tener hijos
Nota: el proceso es independiente el uno del otro, el fin de las principales carreras de códigos proceso, el demonio de resolver de modo inmediato
1, demonio se dará por terminado después del final del código principal proceso de ejecución
de tiempo de importación
de multiprocesamiento proceso de importación
DEF FUNC ():
print ( 'sub-proceso de inicio')
del time.sleep (3) # durmió tres segundos cuando el código principal de la ejecución del proceso ya terminado, por lo que el proceso hijo seguirá el final de la
impresión ( 'end sub-proceso')
SI __name__ == '__main__':
el p = proceso (target = FUNC)
p.daemon = true # demonio está atributos de proceso
p.start ()
la time.sleep (2) # duerme 2 segundos, la aplicación de la sub-proceso
de impresión ( 'proceso primario')
resultado:
el niño se inicia
el proceso principal
2, el demonio terminará después del final de la ejecución principal código de proceso, pero las esperas proceso principal para el proceso hijo final se terminó oficialmente.
Nota: El código se refiere al código que se ejecuta al final de la última línea, no significa que el proceso ha terminado.
tiempo de importación
Proceso de multiprocesamiento Importar de
DEF FUNC ():
count = 1
el while True:
Imprimir ( '*' * COUNT)
del time.sleep (1)
count = 1 +
func2 DEF ():
print ( 'comienza el proceso ordinario')
el time.sleep ( 5)
Imprimir (extremo común del proceso ')
SI __name__ == '__main__':
p1 = proceso (target = FUNC)
p1.daemon = true
p1.start ()
proceso (target = func2) .start ()
la time.sleep ( 3)
Imprimir ( 'proceso primario')
resultados:
*
proceso normal comienza
**
***
proceso principal
extremos proceso ordinario
3, el papel de demonio
demonio puede reportar en vivo, es un informe del servicio de estar vivo
escena:
Por ejemplo, se escribe una página, el servidor no debe parar, porque una vez que se detiene el servidor, otros no pueden acceder a su sitio web, por lo que debe asegurarse de que el servidor no está 'muerto',
esta vez podemos usar servidor, puesto que, en su servicio un demonio, permitir que el proceso a una sola cosa, es decir, cada hora (arreglos razonables de tiempo de acuerdo con su propio conjunto) informar a una máquina de estar vivo,
una vez la máquina no recibió su demonio de las noticias, entonces se puede pensar que su servidor ha colgado.
Por ejemplo:
Importación Tiempo
de multiprocesamiento proceso de importación
DEF Guardia ():
el while True:
la (3600) time.sleep
impresión ( 'estoy vivo') Informe # I a una máquina aún con vida, específicamente cómo escribir un informe sobre cómo la lógica de escritura , aquí es la demostración
SI __name__ == '__main__':
el proceso p = (target = Guardia)
p.daemon = True
p.start ()
# lógica (proceso principal debe ser el principal proceso que se ha ejecutado, no debería ser el final del código tiempo)
Imprimir ( "procedimiento principal")
. 4, terminará: proceso de
tiempo de importación
de multiprocesamiento proceso de importación
DEF Diversión ():
print ( 'proceso hijo')
__name__ == SI '__main__':
el proceso p = (target = diversión)
p.start ()
p.terminate () # cerca el proceso, no se cierra de inmediato, por lo is_alive ver resultados inmediatos pueden seguir vivo
impresión (p.is_alive ( )) # TRUE
la time.sleep (0,1)
Imprimir (p.is_alive ()) # Falso
segundo lugar, el bloqueo de la cerradura
1, preguntas asíncronos
que todos conocemos los beneficios de los procesos asíncronos que se pueden realizar con una alta eficiencia, pero al utilizar varios procesos cuando los mismos recursos de datos, la seguridad o el orden de los datos dará lugar a confusión.
sistema de entradas de última hora:
los contenidos de un ticket archivo # es: { "COUNT": 3}
# nota debe utilizar comillas dobles, o JSON no reconoce el
# de funcionamiento simultáneo, de alta eficiencia, pero la competencia para escribir el mismo archivo, los datos se escriben a la confusión
tiempo de importación
de importación JSON
de multiprocesamiento proceso de importación
DEF Búsqueda (persona):
con Open ( 'billete') como F:
ticketinfo la json.load = (F)
Imprimir ( '% s califican consultan I:' % persona, ticketinfo [ ' contar'])
get_ticket DEF (Person):
con Open ( 'Ticket') AS F:
ticketinfo la json.load = (F)
la time.sleep (0.2) # analógica leer red de datos de latencia
IF ticketinfo [ 'COUNT']> 0:
Imprimir ( ' % s comprar los boletos Persona%)
ticketinfo [ 'count'] - = 1.
la time.sleep (0,2)
con Open ( 'billete', 'W') como F:
el json.dump (ticketinfo, F)
de la otra:
Imprimir ( '% s no conseguir un boleto' Persona%)
billete DEF (persona):
Buscar (persona)
get_ticket (persona)
SI el __name__ == '__main__':
for i in range (5.):
P = Proceso (target = boleto, = args ( '% S Persona' I%,))
P.start ()
resultado:
consulta person0 de votos: 3
consulta person4 de votos: 3
person1 consulta que votos: 3
person2 consulta de votos: 3
persona3 consulta de votos: 3
person0 comprar los boletos
person4 comprar los boletos
person1 comprar los boletos
person2 comprar los boletos
persona3 consiguieron los boletos
de análisis : billete de sólo tres, sino cinco personas han comprado el programa, ya que cinco proceso asíncrono, estamos en la misma vez que se modifica un archivo, la confusión causada.
2, con cerradura resolvió:
# bloqueo reduce la eficiencia del programa, por lo que el código original que se puede ejecutar al mismo tiempo convertirse en el orden de ejecución, el proceso se vuelve asíncrono sincronización
# garantizar la seguridad de los datos de
tiempo de importación
JSON importación
de proceso de importación de multiprocesamiento
de multiprocesamiento de importación clase Lock # importación
DEF Búsqueda (persona):
con Open ( 'billete') como F:
ticketinfo la json.load = (F)
Imprimir ( '% s califican consultan I:' % persona, ticketinfo [ 'count'])
DEF get_ticket (Person):
con Open ( 'Ticket') AS F:
ticketinfo la json.load = (F)
la time.sleep (0.2) # analógica leer red de datos de latencia
IF ticketinfo [ 'COUNT']> 0:
Imprimir ( '% s comprar persona%) las entradas
ticketinfo [ 'COUNT'] -. = 1
la time.sleep (0.2)f)
más:
con Open ( 'billete','W') como f:
json.dump (ticketinfo, f)
1, mecanismo de aplicación de semáforos: + contador de bloqueo implementado
imprimir ( '% s no conseguir un boleto' % la Persona)
DEF entradas (la persona, Lock):
Buscar (la persona)
lock.acquire () # que recibe las llaves para entrar a los que
get_ticket (la persona)
lock.release () # agota, la clave para la siguiente persona
SI el __name__ == '__main__':
bloqueo de bloqueo = () # Crea un objeto de bloqueo
for i in range (. 5):
P = Proceso (target = entradas, args = ( '% S persona' I% , Lock))
p.start ()
resultado:
consulta PERSON1 de votos: 3
persona3 consulta de votos: 3
person0 consulta de votos: 3
consulta PERSON2 de votos: 3
person4 consulta de votos: 3
PERSON1 comprar los boletos
persona3 compran entradas los
person0 comprar los boletos
person2 no conseguir un boleto
person4 no compraron boletos
tres semáforos semáforo
Señal de sincronización basado en la cantidad de contador interno llamado una vez cada Acquire (), el contador se decrementa en 1; una vez por liberación de la llamada (), el contador se incrementa en 1 cuando el contador es 0, acquire () llamada es bloqueada.
Mutex al tiempo que permite sólo un hilo para cambiar los datos, mientras que al mismo tiempo permite que el semáforo Semáforo es un cierto número de hilos para cambiar los datos (Samphore el equivalente a unas pocas teclas, bloqueo sólo una tecla)
Importación Tiempo
de importación aleatoria
del proceso de importación de multiprocesamiento
de multiprocesamiento semáforo de importación
DEF Changba (la persona, sem): # cantar cantar
sem.acquire () # puede venir en las dos primeras personas a
imprimir ( '% s entró cantar' la persona%)
del time.sleep (random.randint ( 3,6)) # tiempo todo el mundo cantando
print ( '% s de Sing' % persona) # sang licencia
sem.release () # la llave a la siguiente persona
SI __name__ == '__main__':
SEM = semáforo (2) # 2 teclas
para I en cobertura (5.):
P = Proceso (target = Changba, args = ( '% S Persona' I%, SEM))
p.start ()
En cuarto lugar, el evento Evento
Python hilo de los acontecimientos para el hilo principal para llevar a cabo otros hilos de control, las ofertas de eventos establecen tres métodos principales, espera, claro.
Evento mecanismo de manejo: Global define una "bandera", si "la bandera" valor es falso, será bloqueado cuando el programa se ejecuta event.wait método, si el valor de "bandera" es verdadera, entonces el método no cuando se event.wait reestenosis.
El bloqueo de evento: método wait ()
espera para ver si el bloqueo se encuentra dentro del evento de objetos bandera de
los valores de la bandera de control:
el SET () para cambiar el valor de la bandera verdadera
Clear () para cambiar el valor de la bandera falsa
is_set () para determinar la actual bandera los valores de
la luz del semáforo:
importación Tiempo
de importación aleatoria
de multiprocesamiento proceso de importación
del Evento multiprocesamiento importación
DEF traffic_ligth (E): # luces de
imprimir ( '\ 033 [31m de luz roja \ 033 [0m') por defecto # Bandera es falso
el while True:
SI E. is_set (): # Si verde
time.sleep (2) # 2 segundos
imprimir ( '\ 033 [31m de luz roja \ 033 [0m') se puso rojo #
e.clear () # se establece en False
la cosa: si la luz es roja #
time.sleep (2) # 2 segundos
print ( ' \ 033 [32m luz verde \ 033 [0m ') # cambiar a verde
e.set () # se establece en True
DEF coche (E, I): # coche
si no es e.is_set ():
print (' % S en el coche esperar '% I)
e.wait ()
Imprimir (' % CAR S a través de un '% I)
SI el __name__ ==' __main__ ':
E = el Evento ()
P = Proceso (objetivo = traffic_ligth, args = (E,)) # semáforos proceso
p.daemon = True
p.start ()
p_lst = []
for i in the Range (10): # 10 coches, por supuesto,
la time.sleep (random.randrange (0,3,2))
el proceso p = ( target = coche, args = (e ,yo))
() p.start
p_lst.append (el p-)
para la p-en p_lst: p.join ()
V. Resumen
entre los procesos, aunque la memoria no se comparte, pero se puede comunicar con
bloqueo de semáforo eventos están llevando a cabo las comunicaciones entre la ciudad
pero no puede cambiar el contenido de la comunicación que
seguimos, así como entre las colas y los tubos para que el proceso de la comunicación