Quelle est l'utilité de join() dans le threading Python ?

Question

J'étudiais le threading de python et je suis tombé sur join() .

L'auteur a dit que si le thread est en mode démon, je dois utiliser join() pour que ce thread puisse se terminer avant que le thread principal ne se termine.

mais je l'ai aussi vu utiliser t.join() même si t n'était pas daemon

Voici un exemple de code

import threading
import time
import logging

logging.basicConfig(level=logging.DEBUG,
                    format='(%(threadName)-10s) %(message)s',
                    )

def daemon():
    logging.debug('Starting')
    time.sleep(2)
    logging.debug('Exiting')

d = threading.Thread(name='daemon', target=daemon)
d.setDaemon(True)

def non_daemon():
    logging.debug('Starting')
    logging.debug('Exiting')

t = threading.Thread(name='non-daemon', target=non_daemon)

d.start()
t.start()

d.join()
t.join()

Je ne sais pas à quoi ça sert t.join() car ce n'est pas un démon et je ne vois aucun changement même si je le supprime.

Answer 1

Cet exemple démontre la .join() action :

import threading
import time

def threaded_worker():
    for r in range(10):
        print('Other: ', r)
        time.sleep(2)

thread_ = threading.Timer(1, threaded_worker)
thread_.daemon = True  # If the main thread is killed, this thread will be killed as well. 
thread_.start()

flag = True

for i in range(10):
    print('Main: ', i)
    time.sleep(2)
    if flag and i > 4:
        print(
            '''
            Threaded_worker() joined to the main thread. 
            Now we have a sequential behavior instead of concurrency.
            ''')
        thread_.join()
        flag = False

---

Dehors :

Main:  0
Other:  0
Main:  1
Other:  1
Main:  2
Other:  2
Main:  3
Other:  3
Main:  4
Other:  4
Main:  5
Other:  5

            Threaded_worker() joined to the main thread. 
            Now we have a sequential behavior instead of concurrency.

Other:  6
Other:  7
Other:  8
Other:  9
Main:  6
Main:  7
Main:  8
Main:  9

Answer 2

Dans python 3.x, join() est utilisé pour joindre un thread avec le thread principal, c'est-à-dire que lorsque join() est utilisé pour un thread particulier, le thread principal arrêtera de s'exécuter jusqu'à ce que l'exécution du thread joint soit terminée.

#1 - Without Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
print('Hey, I do not want to loiter!')
'''
Output without join()--> 
You are loitering!
Hey, I do not want to loiter!
You are not loitering anymore! #After 5 seconds --> This statement will be printed

'''
#2 - With Join():
import threading
import time
def loiter():
    print('You are loitering!')
    time.sleep(5)
    print('You are not loitering anymore!')

t1 = threading.Thread(target = loiter)
t1.start()
t1.join()
print('Hey, I do not want to loiter!')

'''
Output with join() -->
You are loitering!
You are not loitering anymore! #After 5 seconds --> This statement will be printed
Hey, I do not want to loiter! 

'''

Answer 3

Lors de la fabrication join(t) pour le thread non-daemon et le thread daemon, le thread principal (ou processus principal) doit attendre t secondes, puis peut aller plus loin pour travailler sur son propre processus. Pendant le t Pendant les secondes d'attente, les deux fils d'enfants doivent faire ce qu'ils peuvent faire, par exemple imprimer un texte. Après le t secondes, si le thread non-daemon n'a toujours pas terminé son travail, il peut encore le faire après que le processus principal ait terminé son travail, mais pour le thread daemon, il a juste manqué sa fenêtre d'opportunité. Cependant, il finira par mourir après la sortie du programme python. Veuillez me corriger si quelque chose ne va pas.

Answer 4

Il y a plusieurs raisons pour que le fil principal (ou tout autre fil) rejoigne d'autres fils de discussion

1. Un thread peut avoir créé ou retenu (verrouillage) certaines ressources. Le thread qui l'appelle peut être capable de libérer les ressources en son nom.

2. join() est un appel bloquant naturel pour que le thread qui appelle join continue après que le thread appelé se soit terminé.

Si un programme python ne se joint pas à d'autres threads, l'interprète python se joindra quand même aux threads non-démons en son nom.

Answer 5

"Quel est l'intérêt d'utiliser join() ?" dites-vous. En réalité, c'est la même réponse que "à quoi sert de fermer les fichiers, puisque python et le système d'exploitation fermeront mon fichier pour moi lorsque mon programme se terminera".

C'est simplement une question de bonne programmation. Vous devez joindre() vos threads au point du code où le thread doit être utilisé. pas ne soit plus exécuté, soit parce que vous devez positivement vous assurer que le thread n'est pas exécuté pour interférer avec votre propre code, soit parce que vous voulez vous comporter correctement dans un système plus large.

Vous pourriez dire "Je ne veux pas que mon code retarde l'obtention d'une réponse" simplement à cause du temps supplémentaire que la fonction join() pourrait exiger. Cela peut être parfaitement valable dans certains scénarios, mais vous devez maintenant prendre en compte le fait que votre code "laisse des miettes pour que python et le système d'exploitation les nettoient". Si vous faites cela pour des raisons de performance, je vous encourage fortement à documenter ce comportement. Ceci est particulièrement vrai si vous construisez une bibliothèque/un paquet que d'autres sont censés utiliser.

Il n'y a aucune raison de ne pas utiliser la fonction join(), si ce n'est pour des raisons de performances, et je dirais que votre code n'a pas besoin d'effectuer cette opération. que bien.