Erstellung und gängige Methoden von Python-Threads (detaillierte Beispiele)

Dieser Artikel vermittelt Ihnen relevantes Wissen über Python. Er stellt hauptsächlich die Erstellung und gängige Methoden von Threads sowie einige Thread-Demonstrationsfälle vor. Ich hoffe, dass er für alle hilfreich ist.

Empfohlenes Lernen: Python-Video-Tutorial

Erstellung und Verwendung von Threads

Es gibt viele Multithreading-Module in Python, unter denen das threading-Modul häufiger vorkommt gebraucht. Werfen wir einen Blick darauf, wie man mit threading Threads erstellt und welche gängigen Methoden es gibt. threading 模块就是比较常用的。下面就来看一下如何利用 threading 创建线程以及它的常用方法。

线程的创建 -threading

函数名	介绍	举例
Thread	创建线程	Thread(target, args)

Thread 的动能介绍：通过调用 threading 模块的 Thread 类来实例化一个线程对象；它有两个参数： target 与 args (与创建进程时，参数相同)。target 为创建线程时要执行的函数，而 args

Erstellung von Threads - Threading

FunktionsnameEinführungThreadErstellen. ThreadsKinetische Energie des Threads Einführung: Instanziieren Sie ein Thread-Objekt, indem Sie die Klasse Thread des Moduls threading aufrufen. Es verfügt über zwei Parameter: target und args (ähnlich wie beim Erstellen eines Prozess, die Parameter sind die gleichen). target ist die Funktion, die beim Erstellen eines Threads ausgeführt werden soll, und args sind die Parameter, die beim Ausführen dieser Funktion übergeben werden müssen. Gemeinsame Methoden von Thread-ObjektenVerwendung Starten Sie die threadBlockieren Sie den Thread, bis die Thread-Ausführung beendet ist.Den Namen des Threads abrufen setName

Beispiele
Th read(target, args)
		Werfen wir einen Blick auf die häufig verwendeten Methoden in Thread-Objekten:
	Funktionsname	Einführung
		start
start()		join
join(timeout=None)		getName

🎜Legen Sie den Namen des Threads fest.🎜🎜setName(name)🎜🎜🎜🎜is_alive🎜🎜Bestimmen Sie, ob der Thread aktiv ist 🎜setDaemon(True)🎜 🎜 🎜🎜

• Startfunktion: Starten Sie einen Thread; kein Rückgabewert oder Parameter.
• Join-Funktion: Wie die Join-Funktion im Prozess muss die Aufgabe des Haupt-Threads warten, bis die Aufgabe des aktuellen Unter-Threads beendet ist, bevor sie weiter ausgeführt werden kann : stellt den Zeitüberschreitungszeitraum für die Blockierung dar. timeout：代表阻塞的超时时间。
• getName 函数：获取当前线程的名字。
• setName 函数：给当前的线程设置名字；参数为 name：是一个字符串类型
• is_alive 函数：判断当前线程的状态是否存货
• setDaemon 函数：它是一个守护线程；如果脚本任务执行完成之后，即便进程池还没有执行完成业务也会被强行终止。子线程也是如此，如果希望主进程或者是主线程先执行完自己的业务之后，依然允许子线程继续工作而不是强行关闭它们，只需要设置 setDaemon() 为 True 就可以了。

PS：通过上面的介绍，会发现其实线程对象里面的函数几乎和进程对象中的函数非常相似，它们的使用方法和使用场景几乎是相同的。

 线程演示案例

 单线程初始案例

演示 多线程之前 先看一下下面这个案例，运行结束后看看共计耗时多久

1、定义一个列表，里面写一些内容。

2、再定义一个新列表，将上一个列表的内容随机写入到新列表中；并且删除上一个列表中随机获取到的内容。

3、这里需要使用到 r andom 内置模块

代码示例如下：

# coding:utf-8import timeimport random


old_lists = ['罗马假日', '怦然心动', '时空恋旅人', '天使爱美丽', '天使之城', '倒霉爱神', '爱乐之城']new_lists = []def work():
    if len(old_lists) == 0:     # 判断 old_list 的长度，如果为0 ，则表示 该列表的内容已经被删光了
        return '\'old_list\' 列表内容已经全部删除'
    old_choice_data = random.choice(old_lists)      # random 模块的 choice函数可以随机获取传入的 old_list 的元素
    old_lists.remove(old_choice_data)               # 当获取到这个随机元素之后，将该元素从 old_lists 中删除
    new_choice_data = '%s_new' % old_choice_data    # 将随机获取到的随机元素通过格式化方式重新赋值，区别于之前的元素
    new_lists.append(new_choice_data)               # 将格式化的新的随机元素添加至 new_lists 列表

    time.sleep(1)if __name__ == '__main__':
    strat_time = time.time()

    for i in range(len(old_lists)):
        work()

    if len(old_lists) ==0:
        print('\'old_lists\' 当前为：{}'.format(None))
    else:
        print(('\'old_lists\' 当前为：{}'.format(old_lists)))

    if not len(new_lists) == 0:
        print(('\'new_lists\' 当前为：{}'.format(new_lists)))
    else:
        print('\'new_lists\' 当前为：{}'.format(None))

    end_time = time.time()
    print('运行结束，累计耗时：{} 秒'.format(end_time - strat_time))

运行结果如下：

---

从运行输出结果我们可以看到整个脚本运行共计耗时7秒，而且 new_lists 列表内的元素都经过格式化处理后加上了 _new ；不仅如此， 因为 random模块的choice函数 原因，new_lists 的内容顺序与 old_lists 也是不一样；每次运行顺序都会不一样，所以 old_lists 的顺序是无法得到保障的。

---

多线程演示案例

代码示例如下：

# coding:utf-8import timeimport randomimport threading


old_lists = ['罗马假日', '怦然心动', '时空恋旅人', '天使爱美丽', '天使之城', '倒霉爱神', '爱乐之城']new_lists = []def work():
    if len(old_lists) == 0:     # 判断 old_list 的长度，如果为0 ，则表示 该列表的内容已经被删光了
        return '\'old_list\' 列表内容已经全部删除'
    old_choice_data = random.choice(old_lists)      # random 模块的 choice函数可以随机获取传入的 old_list 的元素
    old_lists.remove(old_choice_data)               # 当获取到这个随机元素之后，将该元素从 old_lists 中删除
    new_choice_data = '%s_new' % old_choice_data    # 将随机获取到的随机元素通过格式化方式重新赋值，区别于之前的元素
    new_lists.append(new_choice_data)               # 将格式化的新的随机元素添加至 new_lists 列表

    time.sleep(1)if __name__ == '__main__':
    strat_time = time.time()

    print('\'old_lists\'初始长度为：{}'.format(len(old_lists)))	# 获取 old_lists 与 new_lists 最初始的长度
    print('\'new_lists\'初始长度为：{}'.format(len(new_lists)))
    thread_list = []        # 定义一个空的 thread_list 对象，用以下方添加每个线程

    for i in range(len(old_lists)):
        thread_work = threading.Thread(target=work)     # 定义一个线程实例化对象执行 work 函数，因为 work 函数没有参数所以不用传 args
        thread_list.append(thread_work)                 # 将 thread_work 添加进 thread_list
        thread_work.start()                             # 启动每一个线程

    for t in thread_list:   # 通过for循环将每一个线程进行阻塞
        t.join()

    if len(old_lists) ==0:
        print('\'old_lists\' 当前为：{}'.format(None), '当前长度为：{}'.format(len(old_lists)))
    else:
        print(('\'old_lists\' 当前为：{}'.format(old_lists)))

    if not len(new_lists) == 0:
        print('\'new_lists\' 当前长度为：{}'.format(len(new_lists)))
        print('\'new_lists\' 当前的值为：{}'.format(new_lists))
    else:
        print('\'new_lists\' 当前为：{}'.format(None))

    end_time = time.time()
    print('运行结束，累计耗时：{} 秒'.format(end_time - strat_time))

运行结果如下：

---

从运行的结果来看，我们初始的单线程任务耗时为 7秒，在使用多线程之后，仅耗时 1秒就完成了，大大的提高了我们的运行效率。

---

 线程的问题

通过上面的练习，我们发现线程的使用方法几乎与进程是一模一样的。它们都可以互不干扰的执行程序，也可以使得主线程的程序不需要等待子线程的任务完成之后再去执行。只不过刚刚的演示案例中我们使用了 join() 函数进行了阻塞，这里可以吧 join() 去掉，看看执行效果。

与进程一样，线程也存在着一定的问题。

• 线程执行的函数，也同样是无法获取返回值的。
• 当多个线程同时修改文件一样会造成被修改文件的数据错乱的错误（因为都是并发去操作一个文件，特别是在处理交易场景的时候，需要尤为注意）。

关于这些线程中存在的问题同样是可以解决的，在下一章节的 线程池与全局锁

getName-Funktion: Ruft den Namen des aktuellen Threads ab.

setName-Funktion: Legen Sie den Namen für den aktuellen Thread fest. Der Parameter ist name: Es handelt sich um einen Zeichenfolgentyp.

is_alive-Funktion: Bestimmen Sie, ob der Status des aktuellen Threads auf Lager ist. 🎜🎜setDaemon-Funktion : Es handelt sich um einen Daemon-Thread. Wenn die Skriptaufgabe ausgeführt wird, wird sie zwangsweise beendet, auch wenn der Prozesspool seine Arbeit noch nicht abgeschlossen hat. Dasselbe gilt für untergeordnete Threads, wenn Sie möchten, dass der Hauptprozess oder der Hauptthread zuerst seine eigene Aufgabe erledigt und die untergeordneten Threads trotzdem weiterarbeiten können, anstatt sie zwangsweise zu schließen. Sie müssen lediglich setDaemon( festlegen. ) zu True reicht aus. 🎜🎜PS: Durch die obige Einführung werden Sie feststellen, dass die Funktionen im Thread-Objekt den Funktionen im Prozessobjekt fast sehr ähnlich sind und ihre Verwendungsmethoden und Verwendungsszenarien nahezu gleich sind. 🎜

Thread-Demonstrationsfall

Single-Thread-Anfangsfall

🎜Demo Vor Multithreading code> Schauen wir uns zunächst den folgenden Fall an. Nachdem wir ihn ausgeführt haben, sehen wir, wie lange es insgesamt gedauert hat. 🎜🎜2. Definieren Sie eine neue Liste, schreiben Sie den Inhalt der vorherigen Liste zufällig in die neue Liste und löschen Sie den zufällig erhaltenen Inhalt aus der vorherigen Liste. 🎜🎜3. Sie müssen das integrierte Modul <code>r andom verwenden 🎜🎜Das Codebeispiel lautet wie folgt: 🎜rrreee🎜Die laufenden Ergebnisse sind wie folgt: 🎜

---

🎜🎜Aus den Ergebnissen der laufenden Ausgabe können wir erkennen, dass die Ausführung des gesamten Skripts 7 Sekunden dauert und die Elemente in der Liste new_lists formatiert und mit _new hinzugefügt wurden. code>; nicht nur das, denn <code>random Der Grund für die Auswahlfunktion des Moduls ist, dass sich die Inhaltsreihenfolge von new_lists von der von old_lists unterscheidet ; die Reihenfolge wird bei jeder Ausführung anders sein, daher ist old_lists > die Reihenfolge nicht garantiert. 🎜

---

Multithreading-Demonstrationsfall

🎜Das Codebeispiel lautet wie folgt: 🎜rrreee🎜Die laufenden Ergebnisse lauten wie folgt: 🎜

---

🎜🎜Aus den laufenden Ergebnissen , unsere erste Bestellung Die Thread-Aufgabe dauerte 7 Sekunden. Nach Verwendung von Multithreading dauerte die Ausführung nur 1 Sekunde, was unsere Betriebseffizienz erheblich verbesserte. 🎜

---

Thread-Problem

🎜Durch die obigen Übungen haben wir herausgefunden, dass die Verwendung von Threads fast genau die gleiche ist wie die von Prozessen. Sie können alle Programme ausführen, ohne sich gegenseitig zu stören, und können auch verhindern, dass das Haupt-Thread-Programm auf den Abschluss der Aufgabe des untergeordneten Threads wartet, bevor es diese ausführt. Es ist nur so, dass wir gerade im Demonstrationsfall die Funktion join() zum Blockieren verwendet haben. Sie können join() hier entfernen, um den Ausführungseffekt zu sehen. 🎜🎜Wie Prozesse haben auch Threads bestimmte Probleme. 🎜🎜🎜Die vom Thread ausgeführte Funktion kann den Rückgabewert ebenfalls nicht erhalten. 🎜🎜Wenn mehrere Threads gleichzeitig Dateien ändern, führt dies auch zu Datenverwirrungen in der geänderten Datei (da alle Threads gleichzeitig eine Datei bearbeiten, müssen Sie besonders bei der Verarbeitung von Transaktionsszenarien besonders vorsichtig sein). 🎜🎜Die in diesen Threads bestehenden Probleme können auch gelöst werden. Wir werden sie im nächsten Kapitel von Thread Pool und Global Lock ausführlich vorstellen. 🎜🎜Empfohlenes Lernen: 🎜Python-Video-Tutorial🎜🎜

Das obige ist der detaillierte Inhalt vonErstellung und gängige Methoden von Python-Threads (detaillierte Beispiele). Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!