Panduan Pantas untuk Modul threading Python dengan Contoh

pengenalan

Modul threading dalam Python menyediakan antara muka peringkat tinggi untuk mencipta dan mengurus benang, membolehkan anda menjalankan kod secara serentak. Ini boleh berguna terutamanya untuk tugas yang boleh dilaksanakan secara selari, seperti operasi terikat I/O. Di bawah ialah senarai kaedah dan fungsi yang biasa digunakan dalam modul benang, dengan contoh ringkas.

1. Benang()

Kelas Benang ialah nadi kepada modul benang. Anda boleh membuat dan memulakan urutan baharu menggunakan kelas ini.

import threading

def print_numbers():
    for i in range(5):
        print(i)

t = threading.Thread(target=print_numbers)
t.start()  # Starts a new thread
t.join()   # Waits for the thread to finish

2. mula ()

Memulakan aktiviti urutan.

t = threading.Thread(target=print_numbers)
t.start()  # Runs the target function in a separate thread

3. sertai([masa tamat])

Menyekat utas panggilan sehingga utas yang kaedah join()nya dipanggil tamat. Secara pilihan, anda boleh menentukan tamat masa.

t = threading.Thread(target=print_numbers)
t.start()
t.join(2)  # Waits up to 2 seconds for the thread to finish

4. is_alive()

Kembalikan Benar jika utas masih berjalan.

t = threading.Thread(target=print_numbers)
t.start()
print(t.is_alive())  # True if the thread is still running

5. current_thread()

Mengembalikan objek Thread semasa, mewakili utas panggilan.

import threading

def print_current_thread():
    print(threading.current_thread())

t = threading.Thread(target=print_current_thread)
t.start()  # Prints the current thread info

6. enumerate()

Mengembalikan senarai semua objek Thread yang masih hidup.

t1 = threading.Thread(target=print_numbers)
t2 = threading.Thread(target=print_numbers)
t1.start()
t2.start()

print(threading.enumerate())  # Lists all active threads

7. active_count()

Mengembalikan bilangan objek Thread yang masih hidup.

print(threading.active_count())  # Returns the number of active threads

8. Kunci()

Objek Kunci ialah kunci primitif yang digunakan untuk menghalang keadaan perlumbaan. Anda boleh menggunakannya untuk memastikan hanya satu urutan mengakses sumber yang dikongsi pada satu masa.

lock = threading.Lock()

def thread_safe_function():
    with lock:  # Acquires the lock
        # Critical section
        print("Thread-safe code")

t = threading.Thread(target=thread_safe_function)
t.start()

9. RLock()

Kunci masuk semula membolehkan benang memperoleh() kunci itu beberapa kali tanpa menyekat dirinya sendiri.

lock = threading.RLock()

def reentrant_function():
    with lock:
        with lock:  # Same thread can acquire the lock again
            print("Reentrant lock example")

t = threading.Thread(target=reentrant_function)
t.start()

10. Keadaan()

Objek Keadaan membenarkan benang menunggu beberapa syarat dipenuhi.

condition = threading.Condition()

def thread_wait():
    with condition:
        condition.wait()  # Wait for the condition
        print("Condition met")

def thread_notify():
    with condition:
        condition.notify()  # Notify the waiting thread

t1 = threading.Thread(target=thread_wait)
t2 = threading.Thread(target=thread_notify)
t1.start()
t2.start()

11. Acara()

Objek Acara digunakan untuk memberi isyarat antara benang. Urutan boleh menunggu acara ditetapkan, dan urutan lain boleh menetapkan acara.

event = threading.Event()

def wait_for_event():
    event.wait()  # Wait until the event is set
    print("Event has been set")

t = threading.Thread(target=wait_for_event)
t.start()
event.set()  # Set the event to allow the thread to continue

12. Semaphore()

Objek Semaphore membolehkan anda mengehadkan bilangan utas yang boleh mengakses sumber secara serentak.

semaphore = threading.Semaphore(2)  # Only 2 threads can access the resource at once

def access_resource():
    with semaphore:
        print("Resource accessed")

t1 = threading.Thread(target=access_resource)
t2 = threading.Thread(target=access_resource)
t3 = threading.Thread(target=access_resource)

t1.start()
t2.start()
t3.start()

13. Pemasa (selang waktu, fungsi)

Benang Pemasa melaksanakan fungsi selepas selang waktu tertentu.

def delayed_function():
    print("Executed after delay")

timer = threading.Timer(3, delayed_function)
timer.start()  # Executes `delayed_function` after 3 seconds

14. setDaemon(Benar)

Benang Daemon berjalan di latar belakang dan keluar secara automatik apabila program utama keluar. Anda boleh membuat benang daemon dengan memanggil setDaemon(True) atau menghantar daemon=True kepada pembina Thread.

t = threading.Thread(target=print_numbers, daemon=True)
t.start()  # Daemon thread will exit when the main program ends

Kesimpulan

Modul threading ialah alat yang berkuasa untuk mengendalikan concurrency dalam Python. Ia menyediakan berbilang kelas dan kaedah untuk mencipta dan mengawal benang, menjadikannya mudah untuk melaksanakan kod secara selari. Daripada menggunakan objek Benang asas kepada mengurus penyegerakan dengan Lock dan Semaphore, modul ini penting untuk menulis atur cara Python serentak.

Atas ialah kandungan terperinci Panduan Pantas untuk Modul threading Python dengan Contoh. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!