import threading
import time

def cpu_task(n):
    """Pure CPU work"""
    count = 0
    for i in range(n):
        count += i * i
    return count

# With GIL: these threads don't run in parallel
# Total time ≈ 2x single thread time
t1 = threading.Thread(target=cpu_task, args=(10_000_000,))
t2 = threading.Thread(target=cpu_task, args=(10_000_000,))

start = time.perf_counter()
t1.start()
t2.start()
t1.join()
t2.join()
elapsed = time.perf_counter() - start
print(f"Threaded: {elapsed:.2f}s")  # ~2.0s on 8-core machine

# Single thread for comparison: ~1.0s
# Expected with true parallelism: ~1.0s
# Actual with GIL: ~2.0s (slower than single thread due to GIL contention!)

import sys

# Check if GIL is active
print(sys._is_gil_enabled())  # True (default) or False

# Disable GIL (requires free-threaded build)
sys._disable_gil()
print(sys._is_gil_enabled())  # False

# Re-enable if needed
sys._enable_gil()

import threading
import time
import sys

def prime_check(n):
    """CPU-intensive: check if numbers are prime"""
    primes = []
    for num in range(2, n):
        is_prime = all(num % i != 0 for i in range(2, int(num**0.5) + 1))
        if is_prime:
            primes.append(num)
    return len(primes)

def run_parallel(threads=4, n=50_000):
    workers = [threading.Thread(target=prime_check, args=(n,)) for _ in range(threads)]
    start = time.perf_counter()
    for w in workers: w.start()
    for w in workers: w.join()
    return time.perf_counter() - start

import asyncio
import aiohttp

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

# asyncio already handles I/O concurrency efficiently WITH the GIL
# Free-threading adds minimal benefit here
async def fetch_all(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        return await asyncio.gather(*tasks)

# With GIL: technically unsafe but usually works due to GIL
# Without GIL: ACTUALLY breaks
counter = 0

def increment():
    global counter
    for _ in range(1_000_000):
        counter += 1  # NOT atomic! Read → modify → write

threads = [threading.Thread(target=increment) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()

print(counter)
# With GIL: usually 4,000,000 (by luck)
# Without GIL: could be 2,847,293 (data race!)

import threading
from threading import Lock
from collections import deque
import queue

# Option 1: Explicit locks
class ThreadSafeCounter:
    def __init__(self):
        self._value = 0
        self._lock = Lock()
    
    def increment(self):
        with self._lock:
            self._value += 1
    
    @property
    def value(self):
        with self._lock:
            return self._value

# Option 2: Use thread-safe data structures
safe_queue = queue.Queue()  # Thread-safe by design
safe_deque = deque()  # Atomic for appendleft/pop in CPython

# Option 3: Atomic operations (Python 3.13+)
from _thread import atomic_int
counter = atomic_int(0)
counter.increment()  # Atomic without a lock

import numpy as np
import threading
import time

def matrix_multiply(size=1000):
    A = np.random.randn(size, size)
    B = np.random.randn(size, size)
    return np.dot(A, B)

# NumPy releases the GIL during heavy computations
# Free-threading gives additional benefits for Python-level orchestration

threads = [threading.Thread(target=matrix_multiply) for _ in range(4)]
start = time.perf_counter()
for t in threads: t.start()
for t in threads: t.join()
print(f"Time: {time.perf_counter() - start:.2f}s")
# Free-threaded: ~30% faster for NumPy due to reduced GIL contention overhead

import threading
from concurrent.futures import ThreadPoolExecutor
import json

def process_record(record):
    """CPU-intensive transformation"""
    # Validate
    if not record.get("id"):
        return None
    
    # Transform (CPU-bound)
    processed = {
        "id": record["id"],
        "normalized_name": record["name"].lower().strip(),
        "hash": hash_record(record),
        "derived_fields": compute_derived_fields(record),
    }
    return processed

def parallel_process(records):
    # With free-threading, this actually uses all CPU cores
    with ThreadPoolExecutor(max_workers=8) as executor:
        results = list(executor.map(process_record, records))
    return [r for r in results if r is not None]

import threading
from bs4 import BeautifulSoup
import requests

results = []
results_lock = threading.Lock()

def scrape_and_process(url):
    # I/O: fetch page
    response = requests.get(url, timeout=10)
    
    # CPU: parse HTML
    soup = BeautifulSoup(response.text, "lxml")
    
    # CPU: extract and transform
    data = extract_structured_data(soup)
    
    with results_lock:
        results.append(data)

# With free-threading: HTML parsing runs truly in parallel
threads = [threading.Thread(target=scrape_and_process, args=(url,)) 
           for url in urls]
for t in threads: t.start()
for t in threads: t.join()

import threading
from transformers import pipeline

classifier = pipeline("sentiment-analysis", model="distilbert-base-uncased")

def classify_batch(texts, results, idx):
    # Hugging Face inference releases GIL for ONNX/torch ops
    # Python orchestration now runs in parallel too
    results[idx] = classifier(texts)

batches = split_into_batches(all_texts, n=4)
results = [None] * 4
threads = [
    threading.Thread(target=classify_batch, args=(batch, results, i))
    for i, batch in enumerate(batches)
]
for t in threads: t.start()
for t in threads: t.join()

all_results = [item for batch in results for item in batch]