import threading
import time

def worker(name, delay):
    """스레드에서 실행될 함수"""
    print(f"[{name}] 작업 시작!")
    time.sleep(delay)  # I/O 작업 시뮬레이션
    print(f"[{name}] 작업 완료! ({delay}초 걸림)")

# 순차 처리 (비교용)
start = time.time()
worker("작업1", 2)
worker("작업2", 2)
worker("작업3", 2)
print(f"순차 처리 총 시간: {time.time() - start:.2f}초")  # 약 6초

# 멀티스레딩 처리
start = time.time()
threads = []
for i in range(1, 4):
    t = threading.Thread(target=worker, args=(f"작업{i}", 2))
    threads.append(t)
    t.start()  # 스레드 시작!

for t in threads:
    t.join()  # 모든 스레드 완료 대기

print(f"멀티스레딩 총 시간: {time.time() - start:.2f}초")  # 약 2초!

import threading
import time

class DownloadThread(threading.Thread):
    def __init__(self, url, name):
        super().__init__()
        self.url = url
        self.name = name
        self.result = None
    
    def run(self):
        """스레드 실행 시 자동으로 호출되는 메서드"""
        print(f"[{self.name}] {self.url} 다운로드 시작...")
        time.sleep(2)  # 실제로는 requests.get(self.url) 같은 코드
        self.result = f"{self.url} 다운로드 완료!"
        print(f"[{self.name}] 완료!")

# 스레드 생성 및 실행
threads = [
    DownloadThread("https://example.com/file1.zip", "다운로더1"),
    DownloadThread("https://example.com/file2.zip", "다운로더2"),
    DownloadThread("https://example.com/file3.zip", "다운로더3"),
]

for t in threads:
    t.start()

for t in threads:
    t.join()
    print(f"결과: {t.result}")

import threading

counter = 0
lock = threading.Lock()  # 잠금 객체 생성

def increment_safe():
    global counter
    for _ in range(100000):
        with lock:  # 잠금 획득 (자동으로 해제됨)
            counter += 1

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

print(f"예상값: 500000, 실제값: {counter}")
# 이제 항상 500000 출력! ✅

import threading
import time

# 최대 3개의 스레드만 동시에 실행 허용
semaphore = threading.Semaphore(3)

def api_request(request_id):
    with semaphore:  # 세마포어 획득 (3개 초과 시 대기)
        print(f"요청 {request_id}: API 호출 중...")
        time.sleep(1)  # API 응답 대기 시뮬레이션
        print(f"요청 {request_id}: 완료!")

# 10개의 요청을 동시에 보내지만 최대 3개만 동시 실행
threads = [threading.Thread(target=api_request, args=(i,)) for i in range(10)]
for t in threads: t.start()
for t in threads: t.join()

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def fetch_data(url):
    """URL에서 데이터 가져오기 시뮬레이션"""
    time.sleep(1)  # 네트워크 요청 시뮬레이션
    return f"{url}의 데이터"

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

# 방법 1: map() 사용 - 순서 보장
with ThreadPoolExecutor(max_workers=5) as executor:
    results = list(executor.map(fetch_data, urls))
    print("모든 결과:", results)

# 방법 2: submit() + as_completed() - 완료 순서대로 처리
with ThreadPoolExecutor(max_workers=5) as executor:
    future_to_url = {executor.submit(fetch_data, url): url for url in urls}
    
    for future in as_completed(future_to_url):
        url = future_to_url[future]
        try:
            result = future.result()
            print(f"완료: {url} → {result}")
        except Exception as e:
            print(f"오류 발생: {url} → {e}")

import multiprocessing
import time
import os

def cpu_heavy_task(n):
    """CPU 집약적 작업 시뮬레이션"""
    print(f"프로세스 ID: {os.getpid()}, 작업 {n} 시작")
    result = sum(i * i for i in range(10**7))  # 무거운 계산
    print(f"프로세스 ID: {os.getpid()}, 작업 {n} 완료")
    return result

if __name__ == "__main__":  # 이 부분 중요!! Windows에서 필수!
    # 순차 처리
    start = time.time()
    results = [cpu_heavy_task(i) for i in range(4)]
    print(f"순차 처리: {time.time() - start:.2f}초")
    
    # 멀티프로세싱
    start = time.time()
    processes = []
    for i in range(4):
        p = multiprocessing.Process(target=cpu_heavy_task, args=(i,))
        processes.append(p)
        p.start()
    
    for p in processes:
        p.join()
    
    print(f"멀티프로세싱: {time.time() - start:.2f}초")
    # CPU 코어 수에 따라 4배 가까이 빨라질 수 있음!

import multiprocessing
import time

def producer(queue, items):
    """데이터를 생성해서 큐에 넣는 프로세스"""
    for item in items:
        print(f"생산: {item}")
        queue.put(item)
        time.sleep(0.5)
    queue.put(None)  # 종료 신호

def consumer(queue):
    """큐에서 데이터를 꺼내 처리하는 프로세스"""
    while True:
        item = queue.get()
        if item is None:  # 종료 신호 받으면 종료
            break
        print(f"소비: {item} 처리 완료!")

if __name__ == "__main__":
    queue = multiprocessing.Queue()
    items = ["데이터1", "데이터2", "데이터3", "데이터4", "데이터5"]
    
    p1 = multiprocessing.Process(target=producer, args=(queue, items))
    p2 = multiprocessing.Process(target=consumer, args=(queue,))
    
    p1.start()
    p2.start()
    
    p1.join()
    p2.join()
    print("생산자-소비자 패턴 완료!")

import multiprocessing

def update_counter(counter, lock, n):
    for _ in range(n):
        with lock:
            counter.value += 1

if __name__ == "__main__":
    # 공유 메모리 변수 생성 (타입코드 'i' = 정수)
    counter = multiprocessing.Value('i', 0)
    lock = multiprocessing.Lock()
    
    processes = [
        multiprocessing.Process(target=update_counter, args=(counter, lock, 10000))
        for _ in range(4)
    ]
    
    for p in processes: p.start()
    for p in processes: p.join()
    
    print(f"최종 카운터: {counter.value}")  # 40000
    
    # 배열 공유
    shared_array = multiprocessing.Array('d', [1.0, 2.0, 3.0, 4.0, 5.0])
    print(f"공유 배열: {list(shared_array)}")

from concurrent.futures import ProcessPoolExecutor, as_completed
import time

def heavy_computation(n):
    """CPU 집약적 계산"""
    return sum(i ** 2 for i in range(n))

if __name__ == "__main__":
    numbers = [10**6, 2*10**6, 3*10**6, 4*10**6, 5*10**6]
    
    # 순차 처리
    start = time.time()
    results = [heavy_computation(n) for n in numbers]
    print(f"순차 처리: {time.time() - start:.2f}초")
    
    # ProcessPoolExecutor (CPU 코어 수만큼 자동 설정)
    start = time.time()
    with ProcessPoolExecutor() as executor:
        results = list(executor.map(heavy_computation, numbers))
    print(f"멀티프로세싱: {time.time() - start:.2f}초")
    
    # 결과 확인
    print(f"결과 샘플: {results[0]}")

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

def fetch_url(url):
    """URL에서 데이터 가져오기"""
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        return {
            "url": url,
            "status": response.status_code,
            "length": len(response.content),
            "success": True
        }
    except requests.RequestException as e:
        return {
            "url": url,
            "error": str(e),
            "success": False
        }

def crawl_urls(urls, max_workers=10):
    """여러 URL을 병렬로 크롤링"""
    results = []
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_url = {executor.submit(fetch_url, url): url for url in urls}
        
        for future in as_completed(future_to_url):
            result = future.result()
            results.append(result)
            
            if result["success"]:
                print(f"✅ {result['url']}: {result['length']} bytes")
            else:
                print(f"❌ {result['url']}: {result['error']}")
    
    return results

if __name__ == "__main__":
    urls = [
        "https://httpbin.org/delay/1",
        "https://httpbin.org/delay/2",
        "https://httpbin.org/delay/1",
        "https://httpbin.org/get",
        "https://httpbin.org/ip",
    ]
    
    start = time.time()
    results = crawl_urls(urls, max_workers=5)
    elapsed = time.time() - start
    
    success_count = sum(1 for r in results if r["success"])
    print(f"\n완료! {success_count}/{len(urls)} 성공, 소요 시간: {elapsed:.2f}초")

from PIL import Image
from concurrent.futures import ProcessPoolExecutor
import os
import time
from pathlib import Path

def process_image(args):
    """이미지 처리 함수 (리사이즈 + 그레이스케일)"""
    input_path, output_path, size = args
    
    try:
        with Image.open(input_path) as img:
            # 리사이즈
            img_resized = img.resize(size, Image.LANCZOS)
            # 그레이스케일 변환
            img_gray = img_resized.convert('L')
            # 저장
            img_gray.save(output_path, quality=85)
        return f"✅ {input_path} → {output_path}"
    except Exception as e:
        return f"❌ {input_path}: {e}"

def batch_process_images(input_dir, output_dir, size=(800, 600)):
    """디렉토리 내 모든 이미지 병렬 처리"""
    input_path = Path(input_dir)
    output_path = Path(output_dir)
    output_path.mkdir(exist_ok=True)
    
    # 처리할 이미지 목록 생성
    image_files = list(input_path.glob("*.jpg")) + list(input_path.glob("*.png"))
    
    if not image_files:
        print("처리할 이미지가 없습니다!")
        return
    
    # 인자 리스트 생성
    args_list = [
        (str(img), str(output_path / img.name), size)
        for img in image_files
    ]
    
    print(f"총 {len(image_files)}개 이미지 처리 시작...")
    start = time.time()
    
    # CPU 코어 수만큼 프로세스 사용
    with ProcessPoolExecutor(max_workers=os.cpu_count()) as executor:
        results = list(executor.map(process_image, args_list))
    
    elapsed = time.time() - start
    
    for result in results:
        print(result)
    
    print(f"\n처리 완료! 소요 시간: {elapsed:.2f}초")
    print(f"평균 처리 속도: {len(image_files)/elapsed:.1f}장/초")

if __name__ == "__main__":
    batch_process_images("./input_images", "./output_images")

import multiprocessing
from concurrent.futures import ThreadPoolExecutor
import time
import requests

def fetch_batch(urls):
    """하나의 프로세스에서 여러 URL을 스레드로 처리"""
    def fetch(url):
        try:
            # 실제로는 requests.get(url) 사용
            time.sleep(0.5)  # 네트워크 요청 시뮬레이션
            return f"{url}: 성공"
        except Exception as e:
            return f"{url}: 실패 - {e}"
    
    # 프로세스 내에서 스레드 풀 사용
    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(fetch, urls))
    return results

def split_list(lst, n):
    """리스트를 n개로 균등 분할"""
    k, m = divmod(len(lst), n)
    return [lst[i*k+min(i,m):(i+1)*k+min(i+1,m)] for i in range(n)]

if __name__ == "__main__":
    # 100개의 URL 처리
    all_urls = [f"https://api.example.com/item/{i}" for i in range(100)]
    
    cpu_count = multiprocessing.cpu_count()
    url_batches = split_list(all_urls, cpu_count)
    
    print(f"CPU 코어: {cpu_count}개, 배치당 URL: {len(url_batches[0])}개")
    
    start = time.time()
    
    with multiprocessing.Pool(processes=cpu_count) as pool:
        all_results = pool.map(fetch_batch, url_batches)
    
    # 결과 평탄화
    flat_results = [item for batch in all_results for item in batch]
    
    print(f"총 {len(flat_results)}개 처리 완료!")
    print(f"소요 시간: {time.time() - start:.2f}초")

import time
import functools
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import os

def benchmark(func, *args, **kwargs):
    """함수 실행 시간 측정 데코레이터"""
    start = time.perf_counter()
    result = func(*args, **kwargs)
    elapsed = time.perf_counter() - start
    return result, elapsed

def compare_approaches(task_func, data_list, label="작업"):
    """순차, 멀티스레딩, 멀티프로세싱 성능 비교"""
    print(f"\n{'='*50}")
    print(f"📊 {label} 성능 비교 ({len(data_list)}개 항목)")
    print(f"{'='*50}")
    
    # 1. 순차 처리
    _, seq_time = benchmark(lambda: [task_func(d) for d in data_list])
    print(f"순차 처리:        {seq_time:.3f}초")
    
    # 2. 멀티스레딩
    def thread_run():
        with ThreadPoolExecutor(max_workers=os.cpu_count()*2) as ex:
            return list(ex.map(task_func, data_list))
    _, thread_time = benchmark(thread_run)
    print(f"멀티스레딩:       {thread_time:.3f}초 (속도향상: {seq_time/thread_time:.2f}x)")
    
    # 3. 멀티프로세싱
    def process_run():
        with ProcessPoolExecutor(max_workers=os.cpu_count()) as ex:
            return list(ex.map(task_func, data_list))
    _, proc_time = benchmark(process_run)
    print(f"멀티프로세싱:     {proc_time:.3f}초 (속도향상: {seq_time/proc_time:.2f}x)")
    
    print(f"\n🏆 최적 방법: ", end="")
    times = {"순차": seq_time, "스레딩": thread_time, "프로세싱": proc_time}
    best = min(times, key=times.get)
    print(f"{best} ({times[best]:.3f}초)")

# CPU 집약 작업 테스트
def cpu_task(n):
    return sum(i**2 for i in range(n))

# I/O 집약 작업 테스트
def io_task(n):
    time.sleep(0.1)
    return n * 2

if __name__ == "__main__":
    compare_approaches(cpu_task, [500000]*8, "CPU 집약 작업")
    compare_approaches(io_task, list(range(20)), "I/O 집약 작업")