Heim > Artikel > Backend-Entwicklung > 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
Multi-Threading ähnelt der gleichzeitigen Ausführung mehrerer verschiedener Programme:
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:
Zwei Module, die häufig in Python3-Threads verwendet werden, sind:
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.
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:
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>
Zusätzlich zu den Verwendungsmethoden stellt das Thread-Modul auch die Thread-Klasse zur Verarbeitung von Threads bereit:
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 ("退出主线程")
执行以上程序,输出结果为:
Python 的 Queue 模块中提供了同步的、线程安全的队列类,包括FIFO(先入先出)队列Queue,LIFO(后入先出)队列LifoQueue,和优先级队列 PriorityQueue。
这些队列都实现了锁原语,能够在多线程中直接使用,可以使用队列来实现线程间的同步。
Queue 模块中的常用方法:
实例:
#!/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!