Thread in Python: GIL, Ciclo di Vita e Concorrenza

# METODO 1: ereditarietà - da sapere ma sconsigliato
import threading, time

class MioThread(threading.Thread):
    def run(self):
        print(f"Sono {self.name} - ident: {threading.get_ident()}")

# METODO 2: target - quello che voglio io in verifica
def mio_task(nome):
    for i in range(1,4):
        print(f"{nome} -> {i} su {threading.current_thread().name}")
        time.sleep(0.5)  # TIMED_WAITING + rilascia GIL

def main():
    # ERRORE CHE VEDO SEMPRE: chiamare run() invece di start()
    # t = MioThread(); t.run()  # SBAGLIATO: gira nel main, non è un thread!

    # GIUSTO:
    t1 = MioThread(name="Downloader-1")
    t1.start()  # NEW -> RUNNABLE

    t2 = threading.Thread(target=mio_task, args=("Calcolo-A",), name="Worker-2")
    t2.start()

    # METODO CHE USO IO: lambda + args + name - pulito
    t3 = threading.Thread(target=lambda: print(f"Task lambda su {threading.current_thread().name}"), name="Lambda-Worker")
    t3.start()

    print(f"Main continua, non aspetta. t1 is_alive: {t1.is_alive()}")
    t1.join(); t2.join(); t3.join()  # main va in WAITING finché finiscono
    print("Main: tutti finiti")

if __name__ == "__main__":
    main()

# Caso d'uso perfetto per threading: I/O-bound, GIL rilasciato durante I/O
import threading, time, random
from threading import Lock

completati = 0
lock_contatore = Lock()  # serve per contatore condiviso

def download_simulato(url):
    global completati
    thread_name = threading.current_thread().name
    print(f"[{thread_name}] Inizio download: {url}")
    # Simulo rete lenta -> rilascia GIL, altri thread girano
    time.sleep(random.uniform(0.5, 2.0))
    
    with lock_contatore:
        completati += 1
        tot = completati
    print(f"[{thread_name}] Finito {url} - Totale: {tot}/3")

def main():
    urls = ["foto1.jpg", "video.mp4", "doc.pdf"]
    threads = []
    start = time.time()
    
    for i, url in enumerate(urls):
        t = threading.Thread(target=download_simulato, args=(url,), name=f"DL-{i+1}")
        t.start()
        threads.append(t)

    print("[MAIN] Interfaccia libera, posso muovere il mouse... (main RUNNABLE)")

    for t in threads:
        t.join()  # WAITING

    print(f"[MAIN] Tutti finiti in {time.time()-start:.2f}s vs ~4.5s sequenziale")

if __name__ == "__main__":
    main()

import threading

class ContoCorrente:
    def __init__(self):
        self.saldo = 0
        self.lock = threading.Lock()

    # VERSIONE SBAGLIATA - 10 su 10 lo sbagliano al primo colpo
    # def deposita(self, v):
    #     self.saldo += v  # NON atomico: LOAD, ADD, STORE = 3 bytecode, GIL può switchare!

    # VERSIONE GIUSTA 1: Lock esplicito - quella che uso io
    def deposita_sync(self, v):
        with self.lock:  # BLOCKED se occupato, poi RUNNABLE
            self.saldo += v

    # VERSIONE GIUSTA 2: RLock se metodo chiama altro metodo sincronizzato
    # self.rlock = threading.RLock()

    # VERSIONE GIUSTA 3: moderna, senza lock manuale - Queue
    # from queue import Queue - Queue è già thread-safe

conto = ContoCorrente()

def task_deposito():
    for _ in range(10000):
        conto.deposita_sync(1)

t1 = threading.Thread(target=task_deposito, name="T1")
t2 = threading.Thread(target=task_deposito, name="T2")
t1.start(); t2.start()
t1.join(); t2.join()

# Se usi metodo non sincronizzato vedrai 15432, 19211... casuale!
print(f"Saldo atteso 20000, reale: {conto.saldo}")
# Io ho pensato di fare così per farvelo vedere: lanciate 5 volte, vedete 5 risultati diversi

import threading, time

forchetta1 = threading.Lock()
forchetta2 = threading.Lock()

def filosofo1():
    with forchetta1:
        print("Filosofo1 ha forchetta1, vuole forchetta2...")
        time.sleep(0.1)
        with forchetta2:  # aspetta per sempre se l'altro ha forchetta2
            print("Filosofo1 mangia")

def filosofo2():
    with forchetta2:  # ORDINE INVERSO -> DEADLOCK!
        print("Filosofo2 ha forchetta2, vuole forchetta1...")
        time.sleep(0.1)
        with forchetta1:
            print("Filosofo2 mangia")

t1 = threading.Thread(target=filosofo1, name="Filosofo-1")
t2 = threading.Thread(target=filosofo2, name="Filosofo-2")
t1.start(); t2.start()

# Come lo trovo? t1.is_alive() resta True per sempre, Ctrl+C non basta se non daemon
# Fix che voglio: sempre stesso ordine di lock! Oppure con timeout:
# forchetta1.acquire(timeout=1) -> se False, rilascio e riprovo

t1.join(timeout=2)
if t1.is_alive():
    print("⚠️ DEADLOCK rilevato! Filosofo1 ancora BLOCKED dopo 2s")

import time, random
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
from queue import Queue
import threading

# METODO CLASSICO CHE USO IN 4A: ThreadPoolExecutor per I/O
def scarica_url(task_id):
    print(f"Task {task_id} su {threading.current_thread().name}")
    time.sleep(0.5)  # I/O: rilascia GIL
    return task_id * task_id

def demo_thread_pool():
    # Io ho pensato di fare così: 8 worker = buono per I/O in lab
    with ThreadPoolExecutor(max_workers=8, thread_name_prefix="IO-Worker") as pool:
        futures = [pool.submit(scarica_url, i) for i in range(8)]
        for f in as_completed(futures):
            print(f"Risultato: {f.result()}")  # WAITING finché pronto
    print("Pool chiuso automatico con with")

# METODO MODERNO: Produttore-Consumatore con Queue (quello che voglio in verifica)
def demo_queue():
    q = Queue()

    def produttore():
        for i in range(10):
            print(f"[Produttore] metto {i}")
            q.put(i)
            time.sleep(0.1)
        q.put(None)  # sentinella fine

    def consumatore():
        while True:
            item = q.get()  # WAITING se vuota, thread-safe
            if item is None:
                q.put(None)  # avviso altro consumatore
                break
            print(f"[Consumatore {threading.current_thread().name}] preso {item}")
            q.task_done()

    t_prod = threading.Thread(target=produttore, name="Produttore")
    t_cons = threading.Thread(target=consumatore, name="Consumatore")
    t_prod.start(); t_cons.start()
    t_prod.join(); t_cons.join()
    print("Queue svuotata")

# CPU-BOUND: qui ThreadPool NON serve, serve ProcessPool
def calcolo_pesante(n):
    # Simulo CPU: non rilascia GIL
    s = 0
    for i in range(n):
        s += i*i
    return s

def demo_cpu_bound():
    NUM = 5_000_000
    start = time.time()
    # Con ThreadPool: 4 thread ma 1 core -> lento per GIL
    with ThreadPoolExecutor(max_workers=4) as pool:
        list(pool.map(calcolo_pesante, [NUM]*4))
    print(f"ThreadPool CPU-bound: {time.time()-start:.2f}s (GIL blocca)")

    start = time.time()
    # Con ProcessPool: 4 processi, 4 GIL, 4 core reali
    with ProcessPoolExecutor(max_workers=4) as pool:
        list(pool.map(calcolo_pesante, [NUM]*4))
    print(f"ProcessPool CPU-bound: {time.time()-start:.2f}s (vero parallelo)")

if __name__ == "__main__":
    print("--- ThreadPool I/O ---")
    demo_thread_pool()
    print("\n--- Queue Prod/Cons ---")
    demo_queue()
    print("\n--- CPU-bound confronto ---")
    demo_cpu_bound()