python - start - Uso de threading.Thread.join()
threading get_ident() (3)
Soy nuevo en multihilo en python e intento aprender multihilo con el módulo de subprocesos. He hecho un programa muy simple de multi threading y estoy teniendo problemas para entender el método threading.Thread.join .
Aquí está el código fuente del programa que he hecho
import threading
val = 0
def increment():
global val
print "Inside increment"
for x in range(100):
val += 1
print "val is now {} ".format(val)
thread1 = threading.Thread(target=increment, args=())
thread2 = threading.Thread(target=increment, args=())
thread1.start()
#thread1.join()
thread2.start()
#thread2.join()
¿Qué diferencia hace si uso
thread1.join()
thread2.join()
que he comentado en el código anterior? Ejecuté los dos códigos fuente (uno con comentarios y el otro sin comentarios) pero el resultado es el mismo.
Modifiqué el código para que entiendas cómo funciona exactamente join. por lo tanto, ejecute este código con comentarios y sin comentarios, y observe el resultado para ambos.
val = 0
def increment(msg,sleep_time):
global val
print "Inside increment"
for x in range(10):
val += 1
print "%s : %d/n" % (msg,val)
time.sleep(sleep_time)
thread1 = threading.Thread(target=increment, args=("thread_01",0.5))
thread2 = threading.Thread(target=increment, args=("thread_02",1))
thread1.start()
#thread1.join()
thread2.start()
#thread2.join()
Tal como lo indica la documentación relevante , join hace que la persona que llama espere hasta que termina el hilo.
En su caso, el resultado es el mismo porque join no cambia el comportamiento del programa; probablemente se esté utilizando para salir del programa limpiamente, solo cuando todos los hilos hayan terminado.
Una llamada a thread1.join() bloquea el hilo en el que está realizando la llamada, hasta que thread1 . Es como wait_until_finished(thread1) .
Por ejemplo:
import time
def printer():
for _ in range(3):
time.sleep(1.0)
print "hello"
thread = Thread(target=printer)
thread.start()
thread.join()
print "goodbye"
huellas dactilares
hello
hello
hello
goodbye
.join() llamada .join() , goodbye .join() primero y luego 3 * hello .
Además, tenga en cuenta que los hilos en Python no proporcionan ningún rendimiento adicional (en términos de potencia de procesamiento de CPU) debido a algo llamado bloqueo de intérprete global , por lo que son útiles para deshabilitar potencialmente el bloqueo (por ejemplo, IO, red) y el tiempo tareas (p. ej., control numérico) para mantener el hilo principal libre para otras tareas, no le permiten aprovechar múltiples núcleos o CPU; para eso, mira el multiprocessing que utiliza subprocesos pero expone una API equivalente a la de threading .
PLUG: ... y también es por la razón anterior que, si está interesado en la simultaneidad, también puede buscar en una biblioteca fina llamada Gevent, que básicamente hace que el enhebrado sea mucho más fácil de usar, mucho más rápido (cuando tiene muchas actividades simultáneas) y es menos propenso a los errores relacionados con la concurrencia, al tiempo que le permite seguir codificando de la misma manera que con los hilos "reales". También Twisted, Eventlet, Tornado y muchos otros son equivalentes o comparables. Además, en cualquier caso, recomiendo leer estos clásicos: