JOIN()-Methode im Python-THREADING-Modul

Dieser Artikel führt hauptsächlich in ein detailliertes Verständnis der JOIN()-Methode im Python-THREADING-Modul ein. Dieser Artikel fasst das Verständnis der JOIN()-Methode in einer prägnanten und leicht verständlichen Sprache zusammen. Freunde in Not können sich darauf beziehen

Ich habe sehr davon profitiert, die beiden Codes auf Oschina zu lesen. Unter anderem verstehe ich die Methode „join()“ nicht. Siehe die Einleitung des offiziellen Python-Website-Dokuments:
join([timeout]): Warten Sie, bis der Prozess beendet ist. Dadurch wird der aufrufende Thread blockiert, bis der Thread endet, für den die Methode „join()“ aufgerufen wird. (Es ist schwer zu übersetzen, das sollte es bedeuten)

Haha, das ist leicht zu verstehen.
Join-Methode: Wenn ein Thread oder eine Funktion während der Ausführung einen anderen Thread aufrufen muss und die Ausführung nicht fortgesetzt werden kann, bis sie abgeschlossen ist, kann beim Aufrufen dieses Threads die Join-Methode des aufgerufenen Threads verwendet werden.

Code kopieren Der Code lautet wie folgt:

#-*- 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()

Im Programm ist der letzte Aufruf der join()-Methode klar Der Hauptprozess ruft nacheinander die Methode „join()“ von Thread auf. Wenn die Ausführung aller vier Threads abgeschlossen ist, führt der Hauptthread den folgenden Code aus, was bedeutet, dass er hier beendet wird.
Eine weitere entsprechende Methode im Internet:
3. Daemon-Prozess

setDaemon()

Diese Methode ist im Grunde das Gegenteil von Join. Wenn wir einen Hauptthread ausführen, während das Programm ausgeführt wird, werden der Hauptthread und der Unterthread getrennt ausgeführt, wenn der Hauptthread einen Unterthread erstellt. Es wird geprüft, ob der Unterthread abgeschlossen ist. Wenn der untergeordnete Thread nicht abgeschlossen ist, wartet der Hauptthread, bis der untergeordnete Thread abgeschlossen ist, bevor er beendet wird. Manchmal benötigen wir jedoch Folgendes: Solange der Hauptthread abgeschlossen ist, muss er unabhängig davon, ob der Unterthread abgeschlossen ist, zusammen mit dem Hauptthread beendet werden. In diesem Fall können wir die setDaemon-Methode

Das obige ist der detaillierte Inhalt vonJOIN()-Methode im Python-THREADING-Modul. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!