Python Multithreading Example: Învață să Folosești Multithreading în Python

Cum Să Folosești Modulul threading În Python?

În Python, pentru a utiliza multithreading-ul, trebuie să importăm modulul threading. Vom crea un thread care va executa o funcție specifică. Iată un exemplu simplu de multithreading în Python:

import threading

def salut():
    print("Salut din thread!")

# Creăm un obiect thread care va executa funcția salut
thread = threading.Thread(target=salut)

# Pornim thread-ul
thread.start()

# Așteptăm ca thread-ul să termine
thread.join()

În acest exemplu, am definit o funcție salut() care va fi executată într-un thread separat. Folosim threading.Thread pentru a crea un thread și start() pentru a-l lansa. Funcția join() este folosită pentru a aștepta ca thread-ul să termine înainte de a continua cu programul principal.

Exemplu de Multithreading cu Mai Multe Thread-uri

În multe cazuri, va trebui să rulezi mai multe task-uri simultan. Iată un exemplu de utilizare a mai multor thread-uri pentru a executa funcții diferite în paralel:

import threading

def task_1():
    print("Task 1 începere")
    for i in range(5):
        print(f"Task 1 - {i}")

def task_2():
    print("Task 2 începere")
    for i in range(5):
        print(f"Task 2 - {i}")

# Creăm thread-uri pentru fiecare funcție
thread1 = threading.Thread(target=task_1)
thread2 = threading.Thread(target=task_2)

# Pornim thread-urile
thread1.start()
thread2.start()

# Așteptăm ca thread-urile să termine
thread1.join()
thread2.join()

print("Toate task-urile s-au terminat!")

În acest exemplu, am definit două funcții, task_1() și task_2(), fiecare executând un loop pentru a simula o sarcină. Am creat două thread-uri, thread1 și thread2, și le-am pornit simultan folosind start(). După aceea, am folosit join() pentru a ne asigura că ambele thread-uri au terminat înainte de a continua cu restul codului.

Gestionarea Excepțiilor în Thread-uri

În multithreading, este important să gestionezi excepțiile care pot apărea într-un thread, pentru a preveni blocarea întregului program. Deși fiecare thread rulează independent, este recomandat să capturezi excepțiile care pot apărea în interiorul acestuia. Iată cum poți face asta:

import threading

def task_with_exception():
    try:
        print("Task cu excepție începe!")
        # Provocăm o excepție
        x = 1 / 0
    except ZeroDivisionError as e:
        print(f"Excepție capturată: {e}")

# Creăm și pornim thread-ul
thread = threading.Thread(target=task_with_exception)
thread.start()
thread.join()

Aici, am introdus o excepție de divizare la 0 în funcția task_with_exception(). Aceasta este capturată și gestionată cu un bloc try-except. Acest mecanism te ajută să eviți oprirea bruscă a programului atunci când un thread întâmpină o problemă.

Multithreading pentru Sarcini de I/O

Multithreading-ul este extrem de util atunci când lucrezi cu sarcini care implică I/O, cum ar fi citirea și scrierea de fișiere, sau cereri către un server. Deoarece Python folosește un singur thread pentru procesarea I/O, este recomandat să folosești mai multe thread-uri pentru a îmbunătăți performanța. Iată un exemplu de citire simultană a mai multor fișiere:

import threading

def citire_fisier(fisier):
    with open(fisier, 'r') as f:
        continut = f.read()
        print(f"Conținutul fișierului {fisier}: {continut[:100]}...")  # Afișăm doar primele 100 de caractere

# Lista de fișiere
fisier1 = 'fisier1.txt'
fisier2 = 'fisier2.txt'

# Creăm thread-uri pentru citirea fișierelor
thread1 = threading.Thread(target=citire_fisier, args=(fisier1,))
thread2 = threading.Thread(target=citire_fisier, args=(fisier2,))

# Pornim thread-urile
thread1.start()
thread2.start()

# Așteptăm ca thread-urile să termine
thread1.join()
thread2.join()

print("Toate fișierele au fost citite!")

Aici, folosim multithreading pentru a citi două fișiere în paralel, economisind timp și resurse. Fiecare thread citește un fișier și afișează primele 100 de caractere din conținutul acestuia.

Multithreading în Python vs. Multiprocessing

Este important de menționat că Python mai oferă și modulul multiprocessing, care poate fi folosit pentru a crea procese paralele. Diferența principală între threading și multiprocessing este că multiprocessing rulează procese complet separate, ceea ce permite executarea codului pe mai multe nuclee ale procesorului. Dacă vrei să efectuezi calcule intensive pe CPU, multiprocessing poate fi mai eficient decât threading.

Concluzie: Folosirea Multithreading-ului în Python

Multithreading-ul în Python este o tehnică esențială pentru îmbunătățirea performanței aplicațiilor tale, mai ales când lucrezi cu sarcini care pot fi împărțite în procese paralele. Deși Python nu permite execuția complet paralelă din cauza GIL-ului, multithreading-ul este încă extrem de util pentru sarcini de I/O. În acest articol, am discutat despre cum să folosești threading, am dat exemple practice și am arătat cum să gestionezi excepțiile sau să îmbunătățești performanța aplicațiilor tale.

Acum că ai înțeles conceptele de bază ale multithreading-ului în Python, este timpul să începi să experimentezi și să integrezi aceste tehnici în propriile tale aplicații!