Cara menggunakan modul benang untuk pengurusan berbilang benang dalam Python 2.x

Cara menggunakan modul benang untuk pengurusan berbilang benang dalam Python 2.x

Dalam Python, berbilang benang boleh digunakan untuk melaksanakan berbilang tugas secara serentak dalam program yang sama, dengan itu meningkatkan kecekapan berjalan program. Modul threading ialah modul yang disediakan oleh Python untuk menguruskan thread Dengan menggunakan modul threading, kami boleh membuat, mengawal dan mengurus berbilang thread dengan mudah.

Artikel ini akan memperkenalkan cara menggunakan modul threading untuk pengurusan berbilang benang dalam Python 2.x dan memberikan contoh kod yang berkaitan. Pertama, kita perlu mengimport modul threading:

import threading

Seterusnya, kita boleh menggunakan kelas Thread modul threading untuk mencipta thread baharu. Terdapat dua cara untuk mencipta utas: satu adalah untuk membuat instantiate kelas Thread secara langsung, dan satu lagi adalah untuk mewarisi kelas Thread dan mengatasi kaedah run(). Kedua-dua kaedah ini diperkenalkan di bawah.

Kaedah 1: Langsung instantiate kelas Thread

# 创建线程的函数
def worker():
    print('Worker')

# 创建线程实例
t = threading.Thread(target=worker)

# 启动线程
t.start()

# 等待线程结束
t.join()

Dalam contoh di atas, kami mula-mula mentakrifkan fungsi worker(), yang akan berfungsi sebagai tugas untuk thread untuk dilaksanakan. Kemudian, kami membuat instantiated objek Thread t dan menentukan fungsi pelaksanaan thread sebagai worker() melalui parameter sasaran. Seterusnya, kami memanggil kaedah t.start() untuk memulakan benang, dan benang akan mula melaksanakan tugas dalam fungsi worker().

Kaedah 2: Warisi kelas Thread dan ganti kaedah run()

# 创建继承自 Thread 的子类
class MyThread(threading.Thread):
    def run(self):
        print('Worker')

# 创建线程实例
t = MyThread()

# 启动线程
t.start()

# 等待线程结束
t.join()

Dalam kaedah ini, kita perlu mencipta subkelas yang mewarisi daripada kelas Thread dan mengatasi kaedah run() dalam subkelas. Tugas pelaksanaan benang ditakrifkan dalam kaedah run(). Kemudian, kita membuat instantiate objek subkelas t dan menggunakan objek ini untuk memulakan benang. Sama seperti kaedah 1, kita juga boleh menunggu pelaksanaan thread berakhir melalui t.join().

Apabila menggunakan modul threading untuk pengurusan multi-thread, kami sering menghadapi situasi di mana komunikasi data perlu dijalankan antara thread. Dalam modul threading, beberapa primitif penyegerakan disediakan untuk membantu kami merealisasikan perkongsian data dan komunikasi antara thread.

Primitif penyegerakan yang biasa digunakan ialah mutex (Mutex). Kunci Mutex boleh digunakan untuk memastikan bahawa hanya satu utas boleh mengakses sumber yang dikongsi pada masa yang sama. Dalam modul threading, kita boleh menggunakan kelas Lock untuk mencipta mutex.

# 创建互斥锁
lock = threading.Lock()

# 定义一个共享数据
shared_data = []

# 创建线程的函数
def worker():
    # 加锁
    lock.acquire()
    try:
        # 对共享数据进行操作
        shared_data.append('Hello')
        shared_data.append('World')
        print(shared_data)
    finally:
        # 释放锁
        lock.release()

# 创建线程实例
t1 = threading.Thread(target=worker)
t2 = threading.Thread(target=worker)

# 启动线程
t1.start()
t2.start()

# 等待线程结束
t1.join()
t2.join()

Dalam contoh di atas, kami mula-mula mencipta kunci mutex. Kemudian, dalam fungsi worker(), kita mula-mula memanggil kaedah lock.acquire() untuk memperoleh kunci, kemudian mengendalikan data kongsi shared_data, dan akhirnya memanggil kaedah lock.release() untuk melepaskan kunci. Melalui penggunaan kunci mutex, kami boleh memastikan bahawa hanya satu utas boleh mengendalikan shared_data pada masa yang sama dan mengelakkan masalah persaingan data yang disebabkan oleh berbilang utas yang mengakses data kongsi pada masa yang sama.

Selain kunci mutex, modul penjalinan juga menyediakan primitif penyegerakan lain, seperti semaphore, pembolehubah keadaan, peristiwa, dll. Dengan menggunakan primitif penyegerakan ini dengan betul, kita boleh mencapai komunikasi dan penyelarasan antara utas yang kompleks.

Untuk meringkaskan, adalah sangat mudah untuk menggunakan modul penyusutan untuk pengurusan berbilang benang dalam Python 2.x. Kita boleh menggunakan kelas Thread modul threading untuk mencipta thread dan mentakrifkan tugas pelaksanaan thread dalam dua cara (secara langsung instantiating kelas Thread dan mewarisi kelas Thread). Pada masa yang sama, kami juga boleh merealisasikan perkongsian data dan komunikasi antara benang melalui primitif penyegerakan seperti kunci mutex. Menguasai pengetahuan ini, kita boleh menggunakan multi-threading secara fleksibel untuk meningkatkan kecekapan menjalankan program.

Rujukan:

1. Modul penyusunan dokumentasi rasmi Python: https://docs.python.org/2/library/threading.html

Atas ialah kandungan terperinci Cara menggunakan modul benang untuk pengurusan berbilang benang dalam Python 2.x. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!