Nehmen Sie an der Interpretation von Python-Multithreading teil

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python, das hauptsächlich das relevante Wissen über Multithreading einführt, das der gleichzeitigen Ausführung mehrerer verschiedener Programme ähnelt . Ich hoffe, es hilft allen.

Empfohlenes Lernen: Python-Tutorial

Threading-Erklärung

 Multi-Threading ähnelt der gleichzeitigen Ausführung mehrerer verschiedener Programme:

• Die Verwendung von Threads kann die Anzahl reduzieren von Programmen, die viel Zeit in Anspruch nehmen. Die Aufgabe wird zur Bearbeitung in den Hintergrund gestellt.
• Die Benutzeroberfläche kann attraktiver gestaltet werden, sodass, wenn der Benutzer auf eine Schaltfläche klickt, um die Verarbeitung bestimmter Ereignisse auszulösen, ein Fortschrittsbalken angezeigt werden kann, der den Fortschritt der Verarbeitung anzeigt.
• Das Programm läuft möglicherweise schneller.
• Threads sind nützlicher bei der Implementierung einiger Warteaufgaben wie Benutzereingaben, Lesen und Schreiben von Dateien sowie Senden und Empfangen von Daten über das Netzwerk. In diesem Fall können wir einige wertvolle Ressourcen wie Speichernutzung usw. freigeben.

  Es gibt einen Unterschied zwischen einem Thread und einem Prozess während der Ausführung. Jeder unabhängige Thread verfügt über einen Einstiegspunkt für die Programmausführung, eine sequentielle Ausführungssequenz und einen Ausstiegspunkt für das Programm. Threads können jedoch nicht unabhängig ausgeführt werden und müssen im Anwendungsprogramm vorhanden sein, und das Anwendungsprogramm bietet eine Steuerung für die Ausführung mehrerer Threads.
 Jeder Thread verfügt über einen eigenen Satz von CPU-Registern, den sogenannten Thread-Kontext, der den Status der CPU-Register widerspiegelt, die der Thread zuletzt ausgeführt hat.
  Der Anweisungszeiger und das Stapelzeigerregister sind die beiden wichtigsten Register im Thread-Kontext. Der Thread wird immer im Kontext des Prozesses ausgeführt. Diese Adressen werden verwendet, um den Speicher im Adressraum des Prozesses zu markieren dem der Thread gehört.
 Threads können vorbelegt (unterbrochen) werden.
Threads können in die Warteschleife gelegt werden (auch als „Schlafen“ bezeichnet), während andere Threads ausgeführt werden – dies wird als „Thread-Backing-Off“ bezeichnet.
Threads können unterteilt werden in:

• Kernel-Threads: vom Betriebssystemkernel erstellt und widerrufen.
• Benutzerthread: Ein im Benutzerprogramm implementierter Thread ohne Kernel-Unterstützung.

 Zwei Module, die häufig in Python3-Threads verwendet werden, sind:

• _thread
• threading (empfohlen)

 Thread-Modul wurde aufgegeben. Benutzer können stattdessen das Threading-Modul verwenden. Daher kann das Modul „thread“ in Python3 nicht mehr verwendet werden. Aus Kompatibilitätsgründen hat Python3 den Thread in „_thread“ umbenannt.

Beginnen Sie mit dem Erlernen von Python-Threads

  Es gibt zwei Möglichkeiten, Threads in Python zu verwenden: Funktionen oder Klassen zum Umschließen von Thread-Objekten.
Funktional: Rufen Sie die Funktion start_new_thread() im _thread-Modul auf, um einen neuen Thread zu generieren. Die Syntax lautet wie folgt:

_thread.start_new_thread ( function, args[, kwargs] )

  Parameterbeschreibung:

• Funktion – Thread-Funktion.
• args – die an die Thread-Funktion übergebenen Parameter, es muss ein Tupeltyp sein.
• kwargs – optionale Parameter.

  Beispiel:

#!/usr/bin/python3

import _thread
import time

# 为线程定义一个函数
def print_time( threadName, delay):
    count = 0
    while count <p>  Die Ausgabe der Ausführung des obigen Programms ist wie folgt: <br><img src="https://img.php.cn/upload/article/000/000/067/9e54370fdafb34f8739135c680e1aa53-0.png" alt="Nehmen Sie an der Interpretation von Python-Multithreading teil"></p><h2>Thread-Modul</h2><p>  Python3 bietet Unterstützung für Threads durch zwei Standardbibliotheken: _thread und threading. </p>

• _thread bietet einfache Low-Level-Threads und eine einfache Sperre. Seine Funktionen sind im Vergleich zum Threading-Modul relativ eingeschränkt. Zusätzlich zu allen Methoden im _thread-Modul stellt das
• threading-Modul auch weitere Methoden bereit:
• threading.currentThread(): Gibt die aktuelle Thread-Variable zurück.
• threading.enumerate():
  Gibt eine Liste mit laufenden Threads zurück. „Laufen“ bezieht sich auf den Thread nach dem Start und vor dem Ende, mit Ausnahme von Threads vor dem Start und nach der Beendigung.
• threading.activeCount():
  Gibt die Anzahl der laufenden Threads zurück, was das gleiche Ergebnis wie len(threading.enumerate()) hat.

  Zusätzlich zu den Verwendungsmethoden stellt das Thread-Modul auch die Thread-Klasse zur Verarbeitung von Threads bereit:

• run(): Eine Methode zur Darstellung der Thread-Aktivität.
• start(): Thread-Aktivität starten.
• join([time]): Warten Sie, bis der Thread beendet ist. Dadurch wird der aufrufende Thread blockiert, bis die Methode „join()
  “ des Threads abgebrochen wird – normal beendet wird oder eine nicht behandelte Ausnahme ausgelöst wird – oder ein optionaler Timeout auftritt.
• isAlive(): Gibt zurück, ob der Thread aktiv ist.
• getName(): Gibt den Thread-Namen zurück.
• setName(): Setzt den Thread-Namen.

Verwenden Sie das Threading-Modul, um Threads zu erstellen

Wir können eine neue Unterklasse erstellen, indem wir direkt von threading.Thread erben, und die start()-Methode aufrufen, um nach der Instanziierung einen neuen Thread zu starten, das heißt, sie ruft den Lauf des Threads auf( ) Methode:

#!/usr/bin/python3

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.counter, 5)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, counter):
    while counter:
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主线程")

  Die Ausführungsergebnisse des obigen Programms sind wie folgt:

线程同步

  如果多个线程共同对某个数据修改，则可能出现不可预料的结果，为了保证数据的正确性，需要对多个线程进行同步。
  使用 Thread 对象的 Lock 和 Rlock 可以实现简单的线程同步，这两个对象都有 acquire 方法和 release 方法，对于那些需要每次只允许一个线程操作的数据，可以将其操作放到 acquire 和 release 方法之间。如下：
  多线程的优势在于可以同时运行多个任务（至少感觉起来是这样）。但是当线程需要共享数据时，可能存在数据不同步的问题。
  考虑这样一种情况：一个列表里所有元素都是0，线程"set"从后向前把所有元素改成1，而线程"print"负责从前往后读取列表并打印。
  那么，可能线程"set"开始改的时候，线程"print"便来打印列表了，输出就成了一半0一半1，这就是数据的不同步。为了避免这种情况，引入了锁的概念。
  锁有两种状态——锁定和未锁定。每当一个线程比如"set"要访问共享数据时，必须先获得锁定；如果已经有别的线程比如"print"获得锁定了，那么就让线程"set"暂停，也就是同步阻塞；等到线程"print"访问完毕，释放锁以后，再让线程"set"继续。
  经过这样的处理，打印列表时要么全部输出0，要么全部输出1，不会再出现一半0一半1的尴尬场面。
  实例：

#!/usr/bin/python3

import threading
import time

class myThread (threading.Thread):
    def __init__(self, threadID, name, counter):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.counter = counter
    def run(self):
        print ("开启线程： " + self.name)
        # 获取锁，用于线程同步
        threadLock.acquire()
        print_time(self.name, self.counter, 3)
        # 释放锁，开启下一个线程
        threadLock.release()

def print_time(threadName, delay, counter):
    while counter:
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        counter -= 1

threadLock = threading.Lock()
threads = []

# 创建新线程
thread1 = myThread(1, "Thread-1", 1)
thread2 = myThread(2, "Thread-2", 2)

# 开启新线程
thread1.start()
thread2.start()

# 添加线程到线程列表
threads.append(thread1)
threads.append(thread2)

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")

  执行以上程序，输出结果为：

线程优先级队列（Queue）

  Python 的 Queue 模块中提供了同步的、线程安全的队列类，包括FIFO（先入先出)队列Queue，LIFO（后入先出）队列LifoQueue，和优先级队列 PriorityQueue。
  这些队列都实现了锁原语，能够在多线程中直接使用，可以使用队列来实现线程间的同步。
  Queue 模块中的常用方法:

• Queue.qsize() 返回队列的大小
• Queue.empty() 如果队列为空，返回True,反之False
• Queue.full() 如果队列满了，返回True,反之False
• Queue.full 与 maxsize 大小对应
• Queue.get([block[, timeout]])获取队列，timeout等待时间
• Queue.get_nowait() 相当Queue.get(False)
• Queue.put(item) 写入队列，timeout等待时间
• Queue.put_nowait(item) 相当Queue.put(item, False)
• Queue.task_done() 在完成一项工作之后，Queue.task_done()函数向任务已经完成的队列发送一个信号
• Queue.join() 实际上意味着等到队列为空，再执行别的操作

  实例:

#!/usr/bin/python3

import queue
import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, q):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.q = q
    def run(self):
        print ("开启线程：" + self.name)
        process_data(self.name, self.q)
        print ("退出线程：" + self.name)

def process_data(threadName, q):
    while not exitFlag:
        queueLock.acquire()
        if not workQueue.empty():
            data = q.get()
            queueLock.release()
            print ("%s processing %s" % (threadName, data))
        else:
            queueLock.release()
        time.sleep(1)

threadList = ["Thread-1", "Thread-2", "Thread-3"]
nameList = ["One", "Two", "Three", "Four", "Five"]
queueLock = threading.Lock()
workQueue = queue.Queue(10)
threads = []
threadID = 1

# 创建新线程
for tName in threadList:
    thread = myThread(threadID, tName, workQueue)
    thread.start()
    threads.append(thread)
    threadID += 1

# 填充队列
queueLock.acquire()
for word in nameList:
    workQueue.put(word)
queueLock.release()

# 等待队列清空
while not workQueue.empty():
    pass

# 通知线程是时候退出
exitFlag = 1

# 等待所有线程完成
for t in threads:
    t.join()
print ("退出主线程")

  以上程序执行结果：

 推荐学习：python学习教程

Das obige ist der detaillierte Inhalt vonNehmen Sie an der Interpretation von Python-Multithreading teil. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!