import threading
import time

# 기본 스레드 생성
def download_file(url: str) -> None:
    """파일 다운로드를 시뮬레이션합니다."""
    print(f"다운로드 시작: {url}")
    time.sleep(2)  # I/O 대기 시뮬레이션
    print(f"다운로드 완료: {url}")

urls = [
    "https://data.example.com/train.csv",
    "https://data.example.com/val.csv",
    "https://data.example.com/test.csv",
]

# 순차 실행: 약 6초
start = time.time()
for url in urls:
    download_file(url)
print(f"순차 실행: {time.time() - start:.1f}초")

# 병렬 실행: 약 2초
start = time.time()
threads = []
for url in urls:
    t = threading.Thread(target=download_file, args=(url,))
    threads.append(t)
    t.start()

# 모든 스레드 완료 대기
for t in threads:
    t.join()
print(f"스레드 실행: {time.time() - start:.1f}초")

import threading

# 공유 자원 접근 시 Lock 필요
counter = 0
lock = threading.Lock()

def increment(n: int) -> None:
    global counter
    for _ in range(n):
        with lock:  # Lock 획득 → 해제 자동 관리
            counter += 1

threads = [
    threading.Thread(target=increment, args=(100000,))
    for _ in range(4)
]

for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"결과: {counter}")  # 400000 (Lock 없으면 불정확)

import multiprocessing
import time
import math

# CPU 집약적 작업
def heavy_computation(n: int) -> float:
    """무거운 수학 연산을 수행합니다."""
    return sum(math.sqrt(i) for i in range(n))

numbers = [10_000_000] * 4

# 순차 실행
start = time.time()
results_seq = [heavy_computation(n) for n in numbers]
print(f"순차 실행: {time.time() - start:.2f}초")

# 멀티프로세싱 실행
if __name__ == "__main__":
    start = time.time()
    with multiprocessing.Pool(processes=4) as pool:
        results_mp = pool.map(heavy_computation, numbers)
    print(f"멀티프로세싱: {time.time() - start:.2f}초")

import multiprocessing

def process_item(item: tuple[int, str]) -> str:
    idx, text = item
    return f"[{idx}] {text.upper()}"

items = [(i, f"항목_{i}") for i in range(10)]

if __name__ == "__main__":
    with multiprocessing.Pool(4) as pool:
        # map - 단일 인자, 순서 보장
        results = pool.map(process_item, items)

        # starmap - 튜플 언패킹 (여러 인자)
        def add(a: int, b: int) -> int:
            return a + b

        pairs = [(1, 2), (3, 4), (5, 6)]
        sums = pool.starmap(add, pairs)
        print(sums)  # [3, 7, 11]

        # imap - 이터레이터 반환 (메모리 효율적)
        for result in pool.imap(process_item, items):
            print(result)

        # imap_unordered - 순서 무관, 더 빠름
        for result in pool.imap_unordered(process_item, items):
            print(result)

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import time

# I/O 바운드 → ThreadPoolExecutor
def fetch_data(url: str) -> str:
    time.sleep(1)  # I/O 대기
    return f"데이터: {url}"

urls = [f"https://api.example.com/data/{i}" for i in range(10)]

with ThreadPoolExecutor(max_workers=5) as executor:
    # map - 간편한 병렬 실행
    results = list(executor.map(fetch_data, urls))
    print(f"완료: {len(results)}개")

# CPU 바운드 → ProcessPoolExecutor
import math

def compute(n: int) -> float:
    return sum(math.sqrt(i) for i in range(n))

if __name__ == "__main__":
    numbers = [5_000_000] * 8

    with ProcessPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(compute, numbers))
        print(f"결과: {len(results)}개")

from concurrent.futures import ThreadPoolExecutor, as_completed
import time
import random

def process_task(task_id: int) -> dict:
    """가변 시간이 걸리는 작업"""
    duration = random.uniform(0.5, 3.0)
    time.sleep(duration)
    return {"task_id": task_id, "duration": duration}

with ThreadPoolExecutor(max_workers=5) as executor:
    # submit으로 개별 작업 제출
    futures = {
        executor.submit(process_task, i): i
        for i in range(10)
    }

    # 완료되는 순서대로 처리 (순서 무관)
    for future in as_completed(futures):
        task_id = futures[future]
        try:
            result = future.result(timeout=5)
            print(f"태스크 {result['task_id']}: {result['duration']:.2f}초")
        except Exception as e:
            print(f"태스크 {task_id} 실패: {e}")

from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
from pathlib import Path
import json

# 1. 데이터 전처리 병렬화 (CPU 바운드)
def preprocess_image(filepath: str) -> dict:
    """이미지 전처리를 수행합니다."""
    # 실제로는 PIL/OpenCV로 이미지 처리
    return {
        "path": filepath,
        "processed": True,
        "size": Path(filepath).stat().st_size if Path(filepath).exists() else 0,
    }

def parallel_preprocess(filepaths: list[str], workers: int = 4) -> list[dict]:
    """여러 이미지를 병렬로 전처리합니다."""
    with ProcessPoolExecutor(max_workers=workers) as executor:
        results = list(executor.map(preprocess_image, filepaths))
    return results

# 2. API 호출 병렬화 (I/O 바운드)
def call_llm_api(prompt: str) -> str:
    """LLM API를 호출합니다."""
    import time
    time.sleep(1)  # API 대기 시뮬레이션
    return f"응답: {prompt[:20]}..."

def batch_llm_calls(prompts: list[str], workers: int = 10) -> list[str]:
    """여러 프롬프트를 병렬로 API 호출합니다."""
    with ThreadPoolExecutor(max_workers=workers) as executor:
        results = list(executor.map(call_llm_api, prompts))
    return results

# 3. 대용량 파일 병렬 로딩
def load_json_file(filepath: str) -> dict:
    """JSON 파일을 로딩합니다."""
    with open(filepath, "r", encoding="utf-8") as f:
        return json.load(f)

def parallel_load(filepaths: list[str], workers: int = 8) -> list[dict]:
    """여러 JSON 파일을 병렬로 로딩합니다."""
    with ThreadPoolExecutor(max_workers=workers) as executor:
        results = list(executor.map(load_json_file, filepaths))
    return results