Méthode JOIN() dans le module Python THREADING

Cet article présente principalement une compréhension approfondie de la méthode JOIN() dans le module Python THREADING Cet article résume la compréhension de la méthode JOIN() dans un langage concis et facile à comprendre, différent des autres articles. les amis dans le besoin peuvent s'y référer

J'ai beaucoup bénéficié de la lecture des deux codes sur oschina. Parmi eux, je ne comprends pas la méthode join(). Voir l'introduction du document du site officiel de python :
join([timeout]) : attendez la fin du processus. Cela bloquera le thread appelant jusqu'à ce que le thread sur lequel la méthode join() est appelée se termine. (C'est difficile à traduire, c'est ce que cela devrait signifier) ​​

Haha, c'est facile à comprendre.
méthode join, si un thread ou une fonction doit appeler un autre thread pendant l'exécution et ne peut pas continuer l'exécution jusqu'à ce qu'elle soit terminée, alors la méthode join du thread appelé peut être utilisée lors de l'appel de ce thread.

Copier le code Le code est le suivant :

#-*- encoding: gb2312 -*-
import string, threading, time
 
def thread_main(a):
    global count, mutex
    # 获得线程名
    threadname = threading.currentThread().getName()
 
    for x in xrange(0, int(a)):
        # 取得锁
        mutex.acquire()
        count = count + 1
        # 释放锁
        mutex.release()
        print threadname, x, count
        time.sleep(1)
 
def main(num):
    global count, mutex
    threads = []
 
    count = 1
    # 创建一个锁
    mutex = threading.Lock()
    # 先创建线程对象
    for x in xrange(0, num):
        threads.append(threading.Thread(target=thread_main, args=(10,)))
    # 启动所有线程
    for t in threads:
        t.start()
    # 主线程中等待所有子线程退出
    for t in threads:
        t.join()  
 
if __name__ == '__main__':
    num = 4
    # 创建4个线程
    main(4)
###################################################################
#-*- encoding: gb2312 -*-
import threading
import time
 
class Test(threading.Thread):
    def __init__(self, num):
        threading.Thread.__init__(self)
        self._run_num = num
 
    def run(self):
        global count, mutex
        threadname = threading.currentThread().getName()
 
        for x in xrange(0, int(self._run_num)):
            mutex.acquire()
            count = count + 1
            mutex.release()
            print threadname, x, count
            time.sleep(1)
 
if __name__ == '__main__':
    global count, mutex
    threads = []
    num = 4
    count = 1
    # 创建锁
    mutex = threading.Lock()
    # 创建线程对象
    for x in xrange(0, num):
        threads.append(Test(10))
    # 启动线程
    for t in threads:
        t.start()
    # 等待子线程结束
    for t in threads:
        t.join()

Dans le programme, le dernier appel à la méthode join() est clair. le processus principal appelant les sous-processus un par un. Lorsque les quatre threads auront fini de s'exécuter, le thread principal exécutera le code suivant, ce qui signifie qu'il se terminera ici.
Une autre méthode correspondante trouvée sur Internet :
3. Processus démon

setDaemon()

Cette méthode est fondamentalement l'opposé de join. Lorsque nous exécutons un thread principal pendant l'exécution du programme, si le thread principal crée un sous-thread, le thread principal et le sous-thread seront divisés en deux et exécutés séparément. Ensuite, lorsque le thread principal se terminera et voudra se terminer, il vérifiera si le sous-thread est terminé. Si le thread enfant n'est pas terminé, le thread principal attendra que le thread enfant soit terminé avant de quitter. Mais parfois, ce dont nous avons besoin, c'est que tant que le thread principal est terminé, que le sous-thread soit terminé ou non, il doit se terminer avec le thread principal. Dans ce cas, nous pouvons utiliser la méthode setDaemon

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!