import threading
import multiprocessing
import time
import concurrent.futures

# --- Le GIL (Global Interpreter Lock) ---
# CPython n'execute qu'UN SEUL bytecode Python a la fois, meme avec plusieurs threads.
# Consequence : threading n'accelere PAS le code CPU-bound (calculs purs),
# mais reste tres efficace pour le code I/O-bound (reseau, disque, attente).

def tache_cpu_intensive(n):
    # calcul pur : le GIL empeche un vrai parallelisme ici
    total = 0
    for i in range(n):
        total += i ** 2
    return total

def tache_io_intensive():
    # simulateur d'attente reseau/disque : le GIL est LIBERE pendant l'I/O
    time.sleep(1)
    return "termine"

# --- threading : efficace pour l'I/O-bound ---
debut = time.perf_counter()
threads = [threading.Thread(target=tache_io_intensive) for _ in range(5)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"5 taches I/O en parallele : {time.perf_counter() - debut:.2f}s")   # ~1s, pas 5s

# Race condition : probleme classique du multi-threading sur un etat partage
compteur = 0
verrou = threading.Lock()

def incrementer_sans_verrou():
    global compteur
    for _ in range(100_000):
        compteur += 1          # operation NON atomique : lecture puis ecriture

def incrementer_avec_verrou():
    global compteur
    for _ in range(100_000):
        with verrou:            # section critique protegee
            compteur += 1

threads = [threading.Thread(target=incrementer_avec_verrou) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(compteur)     # 400000 garanti grace au verrou

# Autres primitives de synchronisation
evenement = threading.Event()          # signal on/off entre threads
semaphore = threading.Semaphore(3)      # limite le nombre d'acces concurrents
condition = threading.Condition()        # attente/notification entre threads

# --- multiprocessing : contourne le GIL avec de vrais processus separes ---
def calcul_lourd(n):
    return sum(i * i for i in range(n))

if __name__ == "__main__":
    debut = time.perf_counter()
    with multiprocessing.Pool(processes=4) as pool:
        resultats = pool.map(calcul_lourd, [10_000_000] * 4)
    print(f"Multiprocessing (4 coeurs) : {time.perf_counter() - debut:.2f}s")

    # Communication inter-processus : Queue, Pipe (la memoire n'est PAS partagee par defaut)
    queue = multiprocessing.Queue()

    def worker(q):
        q.put("resultat du processus enfant")

    p = multiprocessing.Process(target=worker, args=(queue,))
    p.start()
    p.join()
    print(queue.get())

    # Memoire partagee explicite si necessaire (couteux, a limiter)
    valeur_partagee = multiprocessing.Value("i", 0)
    tableau_partage = multiprocessing.Array("d", [0.0] * 5)

# --- concurrent.futures : API haut-niveau unifiee ---
def traiter_element(x):
    return x ** 2

with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
    # ideal pour de l'I/O-bound (appels API, lecture fichiers)
    resultats = list(executor.map(traiter_element, range(10)))

with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
    # ideal pour du CPU-bound (calculs lourds)
    futures = [executor.submit(calcul_lourd, n) for n in [1_000_000, 2_000_000]]
    for future in concurrent.futures.as_completed(futures):
        print(future.result())