Python multiproceso es un conocimiento muy importante, hoy multi-roscada como explicamos en detalle, con ejemplos de comentarios en los múltiples hilos de código de conocimientos, así como las pruebas.
enhebrado de importación
de enhebrar la importación de bloqueo, Hilo
tiempo de importación, la
'''
multihilo detallada pitón
¿Qué es un tema?
Tema, también conocido como procesos ligeros, el sistema operativo es la unidad más pequeña capaz de operaciones de programación, es la inclusión en el proceso, la operación real del proceso de unidad.
El hilo que no tienen los recursos del sistema, tiene sólo un poco en la operación de los recursos esenciales, pero puede pertenecer a otros hilos comparten el proceso con un proceso de la
Dispone de todos los recursos. Un hilo puede ser creado y destruido otro hilo puede ejecutar simultáneamente a través de múltiples hilos en el mismo proceso
'''
'''
¿Por qué utilizar múltiples hilos?
Un hilo es independiente en el programa, la ejecución de secuencias simultáneas. En comparación con el proceso de separación, el grado de aislamiento entre los hilos en el proceso son más pequeños, que la memoria compartida, identificadores de archivo
Y otros procesos deben indicar.
Debido a la división del hilo de las escalas más pequeñas que el proceso, por lo que los programas de multiproceso concurrencia alta. El proceso tiene una unidad de memoria separada en el proceso de ejecución, y compartida por múltiples hilos
Memoria, mejorando así en gran medida la eficiencia del programa.
Hilo tiene un mayor rendimiento que el proceso, que se debe a las roscas en el mismo proceso tienen en común, nuestro proceso de múltiples hilos comparten un espacio virtual. Enhebrar entorno compartido
Incluyendo el segmento de código proceso, el total de los datos de proceso, el uso de estos datos compartidos, es fácil para la comunicación entre hilos.
Cuando se crea un proceso del sistema operativo, el proceso de reforma debe ser asignado a otro espacio de memoria, y asignar una gran cantidad de recursos, pero es mucho más simple para crear un hilo. Por lo tanto, el uso de múltiples hilos
Coeficiente de rendimiento para lograr el uso concurrente de múltiples procesos a ser más alta.
'''
'''
En resumen, el uso de la programación multi-roscado tiene las siguientes ventajas:
No se puede compartir la memoria entre procesos, pero la memoria compartida entre hilos muy fácilmente.
Cuando se crea un proceso del sistema operativo, es necesario volver a asignar los recursos del sistema para el proceso, pero el costo es mucho menos crear un hilo. Por lo tanto, el uso de múltiples hilos para lograr multi-tarea ejecución concurrente es más eficiente que el uso de múltiples procesos
soporte de lenguaje Python capacidades integradas de multi-threading, en lugar de simplemente como el subyacente planificación del sistema operativo, lo que simplifica la programación multihilo en Python.
'''
'''
Crear una forma común
'''
# Def ejecute (n):
# Print ( 'tarea', n)
# Time.sleep (1)
# print ( '') 2s
# Time.sleep (1)
# 1s impresión ( '')
# Time.sleep (1)
# print ( '') 0s
# Time.sleep (1)
#
# Si __name__ == '__main__':
# T1 = threading.Thread (target = Ejecutar, args = ( 't1',)) # diana nombre de la función (no función) para ser ejecutado, args es una función de los parámetros correspondientes en la forma de una tupla
# T2 = threading.Thread (target = Ejecutar, args = ( 't2',))
# T1.start ()
# T2.start ()
'''
de hilos preferidos: hereda de la clase hilo threading.Thread para definir, por su propia naturaleza es una reconstrucción del método run de la clase Thread
'''
# MyThread clase (threading.Thread):
# Def __init __ (self, n):
# Súper (MyThread, auto) .__ init __ () # función debe escribir el plazo de reconstrucción
# Self.n = n
#
# Def ejecutar (auto):
# Print ( 'tarea', self.n)
# Time.sleep (1)
# print ( '') 2s
# Time.sleep (1)
# 1s impresión ( '')
# Time.sleep (1)
# print ( '') 0s
# Time.sleep (1)
#
# Si __name__ == '__main__':
# T1 = MyThread ( 't1')
# T2 = MyThread ( 'T2')
# T1.start ()
# T2.start ()
'''
hilo de utilidad
El siguiente ejemplo, que se utiliza aquí setDaemon (True) todo el niño hilos se han convertido en un hilo daemon el hilo principal,
Así que cuando el extremo del hilo principal, el hilo hijo llegará a su fin, por lo que cuando el extremo del hilo principal, todo el programa se cierra.
El llamado 'protector del hilo', que es el hilo principal, independientemente de la aplicación de la rosca, siempre y cuando los extremos del hilo niño y el otro hilo principal está terminado, el hilo principal estará cerrada. En otras palabras: el hilo principal no espera a que la ejecución completa del hilo de utilidad para irse.
'''
# Def ejecute (n):
# Print ( 'tarea', n)
# Time.sleep (1)
# print ( '') 3s
# Time.sleep (1)
# print ( '') 2s
# Time.sleep (1)
# 1s impresión ( '')
#
# Si __name__ == '__main__':
# T = threading.Thread (target = Ejecutar, args = ( 't1',))
# T.setDaemon (True)
# T.Start ()
# Impresión ( 'fin')
'''
Como puede verse por los resultados después de ajustar el hilo demonio, el hilo principal cuando el final, el hilo hijo terminará de inmediato, no se ejecuta
'''
'''
Los principales hilo espera para los acabados de hilo hijo
Con el fin de realizar la guardia después de que el extremo del hilo, el hilo principal y luego al final, podemos utilizar el método de unión, para que los principales hilo espera para la ejecución hilo hijo
'''
# Def ejecute (n):
# Print ( 'tarea', n)
# Time.sleep (2)
# print ( '') 5s
# Time.sleep (2)
# print ( '') 3s
# Time.sleep (2)
# 1s impresión ( '')
# Si __name__ == '__main__':
# T = threading.Thread (target = Ejecutar, args = ( 't1',))
# T.setDaemon (Verdadero) Número de hebras para gestionar hilo de utilidad se debe establecer antes del inicio ()
# T.Start ()
# T.join () # establece los principales hilo espera para el extremo del hilo niño
# Impresión ( 'fin')
'''
Multi-hilo compartida variables globales
La unidad más pequeña de la ejecución cuando los hilos unitarios de ejecución de procesos, procesos en el sistema de asignación de recursos, por lo que múltiples hilos en el mismo proceso es un recurso compartido
'''
# = 100 g_num
# Def trabajo 1 ():
# G_num Global
# Para i en el rango de (3):
# G_num + 1 =
# Print ( 'en g_num trabajo 1 es:% d' % g_num)
#
# Def work2 ():
# G_num Global
# Print ( 'en g_num work2 es:% d' % g_num)
#
# Si __name__ == '__main__':
# T1 = threading.Thread (target = trabajo1)
# T1.start ()
# Time.sleep (1)
# T2 = threading.Thread (target = work2)
# T2.start ()
'''
Debido a que es la programación al azar entre los hilos, y cada hilo sólo se puede llevar a cabo después de realizar n barras, datos sucios pueden ocurrir cuando múltiples hilos simultáneamente modifican los mismos datos,
Así que había un bloqueo de rosca que permite un hilo a la hora de realizar la operación. bloqueo de rosca para el bloqueo del recurso, una pluralidad de cerraduras puede ser definido como el código siguiente, cuando se requiera exclusiva
Cuando un recurso en particular, cualquier bloqueo puede bloquear el recurso, como esto puede ser el mismo que cerraduras de las puertas de las que usa diferentes cerraduras.
Debido a que es la programación al azar entre los hilos, si hay varios hilos operan simultáneamente un objeto, si el objeto no está bien protegido, puede causar resultados inesperados de los procedimientos,
Por lo tanto, también llamados "thread-safe".
Para evitar la situación anterior, ha habido bloqueo mutex (bloqueo)
'''
# Def trabajo ():
Sin global #
# Lock.acquire ()
# Temp = n
# Time.sleep (0,1)
# N = temp-1
# Lock.release ()
#
#
# Si __name__ == '__main__':
# = Cerradura de bloqueo ()
# N = 100
# L = []
# Para i en el rango de (100):
# P = Thread (target = trabajo)
# L.append (p)
# P.start ()
# Para p en l:
# P.join ()
'''
cerradura recursiva: el uso de la clase y la clase RLcok bloqueo exactamente lo mismo, pero soportes agrupados, en general, utilizar la clase RLock cuando varios bloqueos no se liberan
'''
# Def func (bloqueo):
# Gl_num Global
# Lock.acquire ()
# Gl_num + 1 =
# Time.sleep (1)
# Impresión (gl_num)
# Lock.release ()
#
#
# Si __name__ == '__main__':
# = 0 gl_num
# Cerradura = threading.RLock ()
# Para i en el rango de (10):
# T = threading.Thread (target = func, args = (cerradura,))
# T.Start ()
'''
Semáforo (BoundedSemaphore clase)
Objeto mutex mientras que permite sólo un hilo para cambiar los datos, mientras que al mismo tiempo semáforo se permite que un cierto número de hilos para cambiar los datos, tales como sanitarios de fosa 3,
Que permite un máximo de 3 personas en el inodoro, la gente tiene que esperar detrás de alguien de adentro hacia afuera con el fin de volver a entrar
'''
# Def ejecutar (n, semáforos):
# Semaphore.acquire () # bloqueado
# Time.sleep (3)
# Print ( 'correr el hilo:% s \ n' % n)
# # Semaphore.release liberación ()
#
#
# Si __name __ == '__main__':
# Num = 0 Zhengzhou multitud hospital, que es mejor http://www.zzzy120.com/
# Semáforo = threading.BoundedSemaphore (5) # máximo de cinco hilos para ejecutar de forma simultánea
# Para i en el rango de (22):
# T = threading.Thread (objetivo = marcha, args = ( 't-% s' % i, semáforo))
# T.Start ()
# Mientras threading.active_count () = 1:
# pasar
# Otra cosa:
# Print ( '---------- ----------- hecho todas las discusiones')
'''
hilo pitón de eventos para el hilo principal para realizar otras hilos de control, el evento es un objeto de sincronización hilo simple, varios métodos proporcionan principalmente los siguientes:
borrar el indicador se establece en False
El conjunto indicador en True
is_set determina si una bandera
espera hubiera estado escuchando bandera, si no se detecta bandera ha sido bloqueado Estado
Evento mecanismo de tramitación: Global define una bandera, cuando el valor es falso, entonces event.wait será bloqueado () cuando el valor del indicador es Verdadero,
Así event.wait () ya no serán bloqueados
'''
evento = threading.Event ()
def más ligero ():
count = 0
event.set () # luz verde inicial a los que
while True:
si 5 <count <= 10:
Event.CLEAR () la luz roja #, bandera clara
imprimir ( "\ 33 [41; lmred luz está encendida ... \ 033 [0m]")
elif contador> 10:
event.set () # verde, pabellón conjunto
count = 0
más:
imprimir ( '\ 33 [42; lmgreen luz está en ... \ 033 [0m')
time.sleep (1)
contar + = 1
coche def (nombre):
while True:
si event.is_set (): # determina si una bandera
imprimir ( '[% s] corriendo .....' % name)
time.sleep (1)
más:
imprimir ( '[% s] ve la luz roja, a la espera ...' Nombre%)
event.wait ()
print ( 'luz verde [% s] está activado, empezar a ir ...' Nombre%)
# HoraInicio = time.time ()
luz = threading.Thread (target = ligero,)
light.start ()
coche = threading.Thread (target = coche, args = ( 'MINT',))
car.start ()
endTime = time.time ()
# Print ( '用 时:', endTime-horaInicio)
'''
GIL Global intérprete
En el entorno no pitón, los casos de un solo núcleo, mientras que sólo una tarea a realizar. Cuando el multi-núcleo puede soportar múltiples hilos simultáneamente. Pero en Python, sin importar cuántos núcleos
Al mismo tiempo, sólo se puede ejecutar un hilo. La razón de esto es debido a la presencia de GIL.
GIL global es toda la intérprete, fuente de Python es considerado el inicio del diseño, para las decisiones de seguridad de datos realizadas. Un hilo que desea realizar, primero debe obtener GIL, podemos
El GIL visto como un "pase", y en un proceso de pitón, GIL es sólo uno. Obtener los pasos de rosca, y un proceso de pitón, GIL es sólo uno,
No puede conseguir pasar el hilo no se le permitió a la CPU. GIL única CPython en sólo porque es llamada CPython subprocesos nativos lenguaje C, por lo que no puede hablar directamente
Como la CPU, pero sólo podemos utilizar GIL garantía al mismo tiempo sólo un hilo para obtener los datos. En PyPy y JPython no es de GIL
pitón al utilizar multi-hilo, proceso nativo se llama lenguaje C.
'''
'''
pitón para diferentes tipos de eficiencia en la ejecución de código es diferente
1, la CPU código intensivos (procesamiento de diversos bucle, cálculo, etc.), en este caso, ya que múltiples cálculos, garrapatas tecnología pronto alcanzar el umbral, entonces la partida de GIL
Suelte y luego competir (vuelta y vuelta interruptor de múltiples hilos, por supuesto, necesidad de consumir recursos), por lo que múltiples hilos en Python para el código intensivo de la CPU no es amigable.
2, IO código intensivos (procesamiento de archivos, los rastreadores web archivo de diseño de lectura y las operaciones de escritura), puede mejorar efectivamente la eficiencia de multi-threading (IO operación tendrá que esperar a que un solo hilo de IO,
Lo que resulta en pérdida de tiempo innecesaria, y puede abrir múltiples hilos en el hilo Un esperas cambian automáticamente al hilo B, no se puede desperdiciar recursos de la CPU, lo que puede mejorar la ejecución del programa
Eficiencia). Así pitón multi-threading más amigable para el código IO-intensiva.
'''
'''
Principalmente depende del tipo de tarea, la tarea nos dividimos en I / O-intensivo y informático intensivo y multi-hilo en un traspaso se divide en conmutación de E / S y el interruptor de tiempo. Si la tarea es pertenece a E / S intensiva,
Sin el uso de multi-threading, llevamos a cabo una operación de E / S está obligado a esperar a que una tarea de E / S frontal se completa detrás de las tareas de E / S se pueden llevar a cabo en el proceso de espera, la CPU está en espera
Estado, entonces si multithreading, a continuación, sólo para pasar a otra tarea de E / S. Por lo que sólo puede tomar ventaja de la CPU a CPU evitar es inactivo, y mejorar la eficiencia. pero
Si la tarea es multiproceso tipo de cálculo, CPU habría estado llevando a cabo su trabajo hasta que después de un cierto tiempo para tomar el camino multithreading interruptor de tiempo para las discusiones del interruptor y la CPU ha estado en condiciones de trabajo,
En esta situación no mejora el rendimiento, frente multi-roscado al cambiar de tareas, también puede resultar en una pérdida de tiempo y recursos, lo que resulta en una degradación del rendimiento. Esto es causado por la encima de dos resultados multi-hilo no se puede explicar.
Conclusión: I / tareas-O intensiva, recomendado multi-hilo, multi-proceso + manera corrutina también se puede utilizar (por ejemplo .: usos múltiples rastreadores de datos arrastran el procesamiento multi-roscado); para las tareas de cálculo intensivo, no esta vez Python aplicar.
'''