Ayer, de hecho, parte de los contenidos de setDaemon han visto, pero en realidad el contenido no es todo.
En primer lugar, vamos a añadir el conocimiento del contenido no terminó ayer
importación tiempo importación enhebrar def escuchar (num): print ( ' escucha está llegando a s% ' % time.ctime ()) time.sleep ( 3 ) print ( ' escuchar es poner fin a las% s ' % time.ctime ()) def juego (num): print ( ' juego está llegando a las% s ' % time.ctime) () time.sleep ( 5 ) de impresión ( ' juego está llegando a su fin en% s ' % time.ctime ()) si __name__ == ' __main__ ' : t1 = threading.Thread (= objetivo escuchan, args = (1 ,)) # t1.setDaemon (Verdadero) t1.start () t1.join () t2 = threading.Thread (target = juego , args = (2 ,)) t2.setDaemon (Verdadero) t2.start () print ( ' hora de finalización es% s ' % time.ctime ())
En la parte superior de esta situación, después de t1join el hilo principal, los principales hilo espera t1 Conclusión Después de la finalización de la reexportación, pero t2 con el setDaemon, por lo que el hilo principal no espera a que el final de t2 ejecución, una vez finalizado el hilo principal, ya no es t2 continuar por más tiempo.
los resultados de salida:
listen está llegando al Mar Abr 7 2020 23:38:45
escuche se termina en Tue Apr 7 2020 23:38:48
juego está llegando a Tue Apr 7 2020 23:38:48
hora de finalización es Tue Apr 7 23:38:48 2020
Luego en el camino llamando hilo, ayer nos dimos cuenta de una de ellas es utilizar la clase Thread en el módulo threading se crea una instancia para implementar los hilos generación
A continuación, llamar directamente:
Importación de roscado de importación Tiempo DEF sayHi (NUM): # de definición de función de cada hilo para ejecutar impresión ( " Número corriente ON:% s " % NUM) la time.sleep ( 3. ) SI la __name__ == ' __main__ ' : T1 = Threading. el hilo (target = sayHi, args = (. 1,)) # genera una instancia de hilo t2 de la threading.Thread = (target = sayHi, args = (2,)) # genera otra instancia hilo t1.start () # iniciar el hilo t2 .start () # iniciar otro hilo de impresión (t1.getName ()) #Obtener el nombre del hilo de impresión (t2.getName ())
Otro se logra heredar la clase, cree una clase que hereda threading.Thread
Debe volver a escribir el método run () después de este proceso debe apuntar a la nota es que hereda esta clase, es decir, que t1.start () cuando llamadas al método
De la siguiente manera:
Importación Threading de importación Tiempo clase MyThread (threading.Thread): DEF __init__ (Ser, NUM): . Threading.Thread __init__ (Ser) self.num = NUM DEF RUN (Ser): # definen cada hilo para funcionar y la función de impresión ( " se ejecutan en Número:% S " % self.num) la time.sleep ( . 3 ) SI la __name__ == ' __main__ ' : T1 . = la MyThread (1 ) T2 = el MyThread (2 ) t1.start () t2.start () print ( " poner fin ...... " )
Luego todos los temas utilizando el t1.join () ayer a realizar la producción final definitivo después de la finalización de la ejecución de todos los hilos
Así que hoy por: threading.activeCount (): Devuelve el número de subprocesos que se ejecutan, y Len (threading.enumerate ()) tienen el mismo resultado
Para lograr esta función
importación tiempo importación enhebrar def escuchar (num): print ( ' escucha está llegando a s% ' % time.ctime ()) time.sleep ( 3 ) print ( ' escuchar es poner fin a las% s ' % time.ctime ()) def juego (num): print ( ' juego está llegando a las% s ' % time.ctime) () time.sleep ( 5 ) de impresión ( ' juego está llegando a su fin en% s ' % time.ctime ()) si __name__ == ' __main__ ' : t1 = threading.Thread (= objetivo escuchan, args = (1 ,)) # t1.setDaemon (Verdadero) t1.start () t2 = threading.Thread (target = juego, args = (2 ,)) t2.start () de impresión (threading.activeCount ()) mientras threading.activeCount () == 1 : impresión ( ' hora de finalización es% s ' % time.ctime ())
Sobre la derecha.
E introdujo hoy dos conceptos muy importantes y Python en un más terrible error, pero afortunadamente sé la noche, de lo contrario no va a aprender
: Concurrent sistema de procesamiento tiene la capacidad de manejar una pluralidad de tareas, la función de conmutación de la CPU, multi-tarea
Paralelos: un sistema que tiene simultánea capacidad de manejar múltiples tareas, reflejados en el proceso real, es un ordenador de múltiples núcleos, realizar diferentes tareas al mismo tiempo el núcleo
Síncrona, asíncrona:
Sync: Cuando el programa se ejecuta a la necesidad de entrada de datos externa, el programa esperará a que la entrada de datos externa
Asíncrono: Después que varían, y van a hacer otra cosa, voy a esperar a que regrese para llevar a cabo la entrada de datos
Se dice que los dos conceptos muy importantes, por encima de la entrevista básica programador le preguntará, también impacta mucho
Aquí es el concepto GIL es válido y no hablará, introducimos un problema
Primero abrimos un proceso multiproceso, el objetivo es hacer que el programa funcione más eficientemente más rápido
Por ejemplo, el partido de ayer y escuchar al mismo tiempo de inicio, era tener ocho segundos, los últimos 5 segundos para completar la
Sin embargo, tras este caso, ver:
En primer lugar, no utilizan varios subprocesos:
importación tiempo importación roscado def añadir (): sum_a = 0 para i en rango (1,100000 ): sum_a + = i retorno sum_a def Cheng (): sum_b = 1 para i en rango (1,100000 ): sum_b * = i volver sum_b si __name__ == ' __main__ ' : hora_inicial = time.time () add () Cheng () print ( ' 用时:% s ' % (time.time () - hora_inicial))
Resultados de salida: Hora: 3.7846882343292236
Luego usamos la computación multihilo:
importación tiempo importación roscado def añadir (): sum_a = 0 para i en rango (1,100000 ): sum_a + = i retorno sum_a def Cheng (): sum_b = 1 para i en rango (1,100000 ): sum_b * = i volver sum_b si __name__ == ' __main__ ' : hora_inicial = time.time () t1= Threading.Thread (target = añadir) t1.start () t1.join () t2 = threading.Thread (target = Cheng) t2.start () t2.join () de impresión ( ' 用时:% s ' % (tiempo de .time () - hora_inicial))
Resultados de salida: Hora: 4.229001998901367
Descubierto por qué el uso multi-hilo, sino también reducir la velocidad, de hecho, no solo prueba, citando resultados de las pruebas de los demás, de todos modos, es tal sentido, ¿por qué
Python lleva a uno de los más grandes errores, no puede ser considerado, sino también para programar la gente de seguridad, pero no creía que esta baja de la
La causa de lo anterior, vistazo a la siguiente figura:
Esto es aproximadamente el significado anterior, de hecho, en el interior, si usted es un usuario de varios hilos que se deben pasar por la CPU GIL, en última instancia, sólo un hilo, y luego alternar entre el complemento y calcula Cheng, no completar esta sección , llamada la competencia parece, mañana suplemento, que se debe a que los dos pasaron tiempo para volver interruptor de un lado a otro finalmente llevó a la utilización de más tiempo
La figura flecha dentro de cada ocurrencia implicará los datos temporales
Aquí pienso en fuga de ayer de un registro de punto de conocimiento.
En primer lugar, nuestro viejo velocidad de la CPU más rápida, lo que resulta en la mayor parte de la razón es debido al proceso de baja velocidad de espera para leer los datos, los siguientes datos se leen desde diferentes lugares de la comparación de velocidad
Base de datos (disco): Ciclismo
Memoria: conducir un coche (bastante caro tipo de coche, la mayoría de los navegadores caché de páginas)
CPU: velocidad es al menos la primera velocidad cósmica
A continuación, el ordenador con el fin de resolver el tiempo de espera para la pérdida de datos durante la lectura, o simplemente en el interior del borde de la CPU abrió un pequeño espacio, algunos muy importante para almacenar datos temporalmente, es el registro de posiciones
Si lo hace, no va a arrastrar las patas traseras de la CPU
Hoy es el contenido, no creo que gran parte de los conocimientos teóricos recientes, mi mente no se ha ido.