from multiprocessing import Process, current_process
import os
import time
from typing import List, Callable, Any, Optional, Dict, Union, Tuple

def basic_worker() -> None:
    """기본 작업자 함수
    
    현재 프로세스 정보를 출력한다.
    """
    process = current_process()
    print(f'프로세스 이름: {process.name}')
    print(f'프로세스 ID: {os.getpid()}')
    print(f'부모 프로세스 ID: {os.getppid()}')
    print(f'프로세스 상태: {"alive" if process.is_alive() else "dead"}')

def worker_with_args(number: int, text: str) -> None:
    """인자를 받는 작업자 함수
    
    Args:
        number: 정수 인자
        text: 문자열 인자
    """
    print(f'프로세스 ID: {os.getpid()}')
    print(f'인자 값: number={number}, text={text}')
    time.sleep(2)  # 작업 시뮬레이션
    print(f'프로세스 {os.getpid()} 작업 완료')

class ProcessManager:
    """프로세스 관리 클래스"""
    
    def __init__(self, max_processes: int = 4):
        """초기화
        
        Args:
            max_processes: 최대 프로세스 수
        """
        self.max_processes = max_processes
        self.processes: List[Process] = []
        
    def create_process(self, target: Callable, args: tuple = (), 
                     kwargs: Dict = None, name: Optional[str] = None) -> Process:
        """새 프로세스 생성
        
        Args:
            target: 실행할 함수
            args: 위치 인자
            kwargs: 키워드 인자
            name: 프로세스 이름
            
        Returns:
            Process: 생성된 프로세스 객체
        """
        if kwargs is None:
            kwargs = {}
            
        p = Process(target=target, args=args, kwargs=kwargs, name=name)
        self.processes.append(p)
        return p
    
    def start_all(self) -> None:
        """모든 프로세스 시작"""
        for p in self.processes:
            p.start()
            print(f'프로세스 시작: {p.name} (PID: {p.pid})')
    
    def join_all(self, timeout: Optional[float] = None) -> None:
        """모든 프로세스 대기
        
        Args:
            timeout: 최대 대기 시간(초)
        """
        for p in self.processes:
            p.join(timeout)
    
    def terminate_all(self) -> None:
        """모든 프로세스 강제 종료"""
        for p in self.processes:
            if p.is_alive():
                p.terminate()
                print(f'프로세스 종료: {p.name} (PID: {p.pid})')
    
    def get_active_count(self) -> int:
        """활성 프로세스 수 반환
        
        Returns:
            int: 활성 프로세스 수
        """
        return sum(1 for p in self.processes if p.is_alive())

# 기본 사용 예시
if __name__ == '__main__':
    # 기본 프로세스 생성 및 실행
    processes = []
    for i in range(3):
        p = Process(target=basic_worker)
        p.start()
        processes.append(p)
    
    for p in processes:
        p.join()
    
    print("\n프로세스 매니저 사용 예시:")
    # 프로세스 매니저 사용
    manager = ProcessManager()
    
    # 여러 프로세스 생성
    for i in range(3):
        manager.create_process(
            target=worker_with_args, 
            args=(i, f"작업 {i}"),
            name=f"Worker-{i}"
        )
    
    # 모든 프로세스 시작 및 대기
    manager.start_all()
    
    print(f"활성 프로세스 수: {manager.get_active_count()}")
    
    manager.join_all()
    print("모든 프로세스 완료")

from multiprocessing import Process, Queue, Pipe, Event
import time
from typing import List, Dict, Any, Tuple, Optional

class QueueCommunication:
    """Queue를 사용한 프로세스 간 통신"""
    
    def sender(self, queue: Queue, data: List[Any]) -> None:
        """데이터를 큐에 전송하는 프로세스
        
        Args:
            queue: 데이터를 보낼 큐
            data: 보낼 데이터 리스트
        """
        for item in data:
            queue.put(item)
            print(f'[Sender] 전송: {item}')
            time.sleep(0.5)  # 전송 간격
        
        # 종료 신호 전송
        queue.put(None)
        print('[Sender] 전송 완료')

    def receiver(self, queue: Queue) -> None:
        """큐에서 데이터를 수신하는 프로세스
        
        Args:
            queue: 데이터를 받을 큐
        """
        while True:
            item = queue.get()
            if item is None:  # 종료 신호 확인
                break
            print(f'[Receiver] 수신: {item}')
        
        print('[Receiver] 수신 완료')
    
    def demonstrate(self, data: List[Any]) -> None:
        """Queue 통신 시연
        
        Args:
            data: 전송할 데이터
        """
        queue = Queue()
        
        sender_process = Process(
            target=self.sender, 
            args=(queue, data)
        )
        receiver_process = Process(
            target=self.receiver, 
            args=(queue,)
        )
        
        sender_process.start()
        receiver_process.start()
        
        sender_process.join()
        receiver_process.join()

class PipeCommunication:
    """Pipe를 사용한 프로세스 간 통신"""
    
    def pipe_process_a(self, conn: Pipe, data: List[Any]) -> None:
        """첫 번째 프로세스
        
        Args:
            conn: 파이프 연결 객체
            data: 전송할 데이터
        """
        for item in data:
            conn.send(item)
            print(f'[Process A] 전송: {item}')
            
            # 응답 대기
            response = conn.recv()
            print(f'[Process A] 수신 확인: {response}')
            
            time.sleep(0.5)
        
        # 종료 신호
        conn.send('END')
        conn.close()
    
    def pipe_process_b(self, conn: Pipe) -> None:
        """두 번째 프로세스
        
        Args:
            conn: 파이프 연결 객체
        """
        while True:
            item = conn.recv()
            if item == 'END':
                print('[Process B] 종료 신호 수신')
                break
                
            print(f'[Process B] 수신: {item}')
            
            # 응답 전송
            conn.send(f'ACK: {item}')
        
        conn.close()
    
    def demonstrate(self, data: List[Any]) -> None:
        """Pipe 통신 시연
        
        Args:
            data: 전송할 데이터
        """
        # 양방향 파이프 생성
        parent_conn, child_conn = Pipe()
        
        process_a = Process(
            target=self.pipe_process_a, 
            args=(parent_conn, data)
        )
        process_b = Process(
            target=self.pipe_process_b, 
            args=(child_conn,)
        )
        
        process_a.start()
        process_b.start()
        
        process_a.join()
        process_b.join()

class EventCommunication:
    """Event를 사용한 프로세스 간 동기화"""
    
    def wait_for_event(self, event: Event) -> None:
        """이벤트 대기 프로세스
        
        Args:
            event: 대기할 이벤트 객체
        """
        print('[대기 프로세스] 이벤트 대기 중...')
        event.wait()  # 이벤트가 설정될 때까지 대기
        print('[대기 프로세스] 이벤트 발생! 작업 시작')
        # 작업 시뮬레이션
        time.sleep(2)
        print('[대기 프로세스] 작업 완료')
    
    def trigger_event(self, event: Event, delay: float) -> None:
        """일정 시간 후 이벤트 트리거 프로세스
        
        Args:
            event: 설정할 이벤트 객체
            delay: 지연 시간(초)
        """
        print(f'[트리거 프로세스] {delay}초 후 이벤트 설정 예정')
        time.sleep(delay)
        print('[트리거 프로세스] 이벤트 설정!')
        event.set()  # 이벤트 설정
    
    def demonstrate(self, delay: float = 3.0) -> None:
        """Event 통신 시연
        
        Args:
            delay: 이벤트 트리거 지연 시간(초)
        """
        event = Event()
        
        wait_process = Process(
            target=self.wait_for_event, 
            args=(event,)
        )
        trigger_process = Process(
            target=self.trigger_event, 
            args=(event, delay)
        )
        
        wait_process.start()
        trigger_process.start()
        
        wait_process.join()
        trigger_process.join()

# 사용 예시
if __name__ == '__main__':
    # Queue 통신 예시
    print("\n===== Queue 통신 예시 =====")
    queue_comm = QueueCommunication()
    queue_comm.demonstrate(['메시지1', '메시지2', '메시지3'])
    
    # Pipe 통신 예시
    print("\n===== Pipe 통신 예시 =====")
    pipe_comm = PipeCommunication()
    pipe_comm.demonstrate(['데이터1', '데이터2', '데이터3'])
    
    # Event 통신 예시
    print("\n===== Event 통신 예시 =====")
    event_comm = EventCommunication()
    event_comm.demonstrate(2.0)

from multiprocessing import Pool, cpu_count
import time
import os
from typing import List, Callable, Any, Dict, Union, Tuple
import functools

def cpu_bound_task(x: int) -> int:
    """CPU 집약적 계산 작업 (예: 소수 판별)
    
    Args:
        x: 작업할 숫자
        
    Returns:
        int: 계산 결과
    """
    if x <= 1:
        return 0
    
    # 소수 판별 (CPU 집약적 작업 시뮬레이션)
    count = 0
    for i in range(2, int(x**0.5) + 1):
        if x % i == 0:
            count += 1
    
    # 작업 시간 시뮬레이션
    time.sleep(0.1)
    
    return count

def io_bound_task(filename: str) -> Tuple[str, int]:
    """I/O 집약적 작업 (예: 파일 처리)
    
    Args:
        filename: 처리할 파일 이름
        
    Returns:
        Tuple[str, int]: (파일명, 처리 결과)
    """
    print(f"프로세스 {os.getpid()}: 파일 {filename} 처리 중")
    
    # I/O 작업 시뮬레이션
    time.sleep(0.5)
    
    # 실제로는 여기서 파일을 읽고 처리
    result = len(filename)
    
    return (filename, result)

def task_with_callback(x: int) -> int:
    """콜백을 위한 작업
    
    Args:
        x: 입력 값
        
    Returns:
        int: 계산 결과
    """
    print(f"작업 {x} 시작 (PID: {os.getpid()})")
    time.sleep(1)  # 작업 시뮬레이션
    result = x * x
    print(f"작업 {x} 완료")
    return result

def result_callback(result: int) -> None:
    """비동기 작업의 결과 처리 콜백
    
    Args:
        result: 작업 결과
    """
    print(f"콜백: 결과 = {result}")

class ProcessPoolManager:
    """프로세스 풀 관리 클래스"""
    
    def __init__(self, processes: int = None):
        """초기화
        
        Args:
            processes: 프로세스 수 (None이면 CPU 코어 수 사용)
        """
        self.processes = processes or cpu_count()
        print(f"프로세스 풀 크기: {self.processes} (가용 CPU: {cpu_count()})")
    
    def map_demonstration(self, func: Callable, iterable: List) -> List:
        """map 메서드 시연
        
        Args:
            func: 적용할 함수
            iterable: 입력 데이터 리스트
            
        Returns:
            List: 결과 리스트
        """
        start_time = time.time()
        
        with Pool(processes=self.processes) as pool:
            results = pool.map(func, iterable)
            
        end_time = time.time()
        print(f"map 실행 시간: {end_time - start_time:.2f}초")
        
        return results
    
    def imap_unordered_demonstration(self, func: Callable, iterable: List) -> List:
        """imap_unordered 메서드 시연 (순서 무관, 결과 즉시 반환)
        
        Args:
            func: 적용할 함수
            iterable: 입력 데이터 리스트
            
        Returns:
            List: 결과 리스트
        """
        start_time = time.time()
        results = []
        
        with Pool(processes=self.processes) as pool:
            for result in pool.imap_unordered(func, iterable):
                print(f"결과 도착: {result}")
                results.append(result)
        
        end_time = time.time()
        print(f"imap_unordered 실행 시간: {end_time - start_time:.2f}초")
        
        return results
    
    def async_demonstration(self, func: Callable, args_list: List) -> List:
        """apply_async 메서드 시연 (비동기 실행)
        
        Args:
            func: 적용할 함수
            args_list: 인자 리스트
            
        Returns:
            List: 결과 리스트
        """
        results = []
        
        with Pool(processes=self.processes) as pool:
            async_results = [
                pool.apply_async(
                    func, 
                    args=(arg,),
                    callback=result_callback
                ) for arg in args_list
            ]
            
            # 모든 결과 수집
            for async_result in async_results:
                result = async_result.get()  # 완료될 때까지 대기
                results.append(result)
        
        return results
    
    def chunksize_comparison(self, func: Callable, iterable: List) -> None:
        """청크 크기에 따른 성능 비교
        
        Args:
            func: 적용할 함수
            iterable: 입력 데이터 리스트
        """
        chunk_sizes = [1, 10, 25, 50]
        
        for chunk_size in chunk_sizes:
            start_time = time.time()
            
            with Pool(processes=self.processes) as pool:
                results = pool.map(func, iterable, chunksize=chunk_size)
            
            end_time = time.time()
            print(f"청크 크기 {chunk_size}: {end_time - start_time:.2f}초")

# 사용 예시
if __name__ == '__main__':
    pool_manager = ProcessPoolManager()
    
    # 1. map 메서드 예시 (CPU 바운드 작업)
    print("\n===== Pool.map 예시 (CPU 바운드) =====")
    numbers = list(range(100, 150))
    results = pool_manager.map_demonstration(cpu_bound_task, numbers)
    print(f"처리된 결과 수: {len(results)}")
    
    # 2. imap_unordered 예시 (I/O 바운드 작업)
    print("\n===== Pool.imap_unordered 예시 (I/O 바운드) =====")
    filenames = [f"file_{i}.txt" for i in range(1, 11)]
    results = pool_manager.imap_unordered_demonstration(io_bound_task, filenames)
    
    # 3. apply_async 예시 (비동기 + 콜백)
    print("\n===== Pool.apply_async 예시 (콜백 포함) =====")
    args_list = [3, 6, 9, 12]
    results = pool_manager.async_demonstration(task_with_callback, args_list)
    print(f"최종 결과: {results}")
    
    # 4. 청크 크기에 따른 성능 비교
    print("\n===== 청크 크기에 따른 성능 비교 =====")
    large_numbers = list(range(100, 300))
    pool_manager.chunksize_comparison(cpu_bound_task, large_numbers)

from multiprocessing import Process, Value, Array, RawValue, RawArray
import time
import ctypes
from typing import List, Callable, Any

class SharedMemoryExample:
    """공유 메모리 사용 예제"""
    
    def process_value(self, value: Value, operation: str) -> None:
        """Value 객체 조작 프로세스
        
        Args:
            value: 공유 Value 객체
            operation: 수행할 연산 (증가 또는 감소)
        """
        for i in range(5):
            with value.get_lock():  # 락 획득
                if operation == 'increase':
                    value.value += 1
                elif operation == 'decrease':
                    value.value -= 1
                    
                print(f"[{operation}] 새 값: {value.value} (PID: {os.getpid()})")
            time.sleep(0.1)
    
    def process_array(self, shared_array: Array, start_idx: int) -> None:
        """Array 객체 조작 프로세스
        
        Args:
            shared_array: 공유 Array 객체
            start_idx: 시작 인덱스
        """
        for i in range(3):
            idx = start_idx + i
            if 0 <= idx < len(shared_array):
                with shared_array.get_lock():  # 락 획득
                    shared_array[idx] = shared_array[idx] * 2
                    print(f"[PID: {os.getpid()}] 인덱스 {idx} 값 변경: {shared_array[idx]}")
            time.sleep(0.2)
    
    def demonstrate_value(self) -> None:
        """Value 객체 데모"""
        # 초기값 0인 정수형 공유 변수 생성
        shared_value = Value('i', 0)
        
        # 두 프로세스 생성
        p1 = Process(target=self.process_value, args=(shared_value, 'increase'))
        p2 = Process(target=self.process_value, args=(shared_value, 'decrease'))
        
        p1.start()
        p2.start()
        
        p1.join()
        p2.join()
        
        print(f"최종 값: {shared_value.value}")
    
    def demonstrate_array(self) -> None:
        """Array 객체 데모"""
        # 초기값 [1,2,3,4,5]인 정수형 공유 배열 생성
        shared_array = Array('i', [1, 2, 3, 4, 5])
        
        processes = []
        for i in range(3):
            p = Process(target=self.process_array, args=(shared_array, i))
            processes.append(p)
            p.start()
        
        for p in processes:
            p.join()
        
        print(f"최종 배열: {list(shared_array)}")
    
    def demonstrate_raw_types(self) -> None:
        """Raw 타입 데모 (락 없음)"""
        # 락 없는 공유 변수
        raw_value = RawValue(ctypes.c_double, 3.14)
        
        # 락 없는 공유 배열
        raw_array = RawArray(ctypes.c_int, 5)
        for i in range(5):
            raw_array[i] = i * 2
        
        def modify_raw(rv, ra):
            rv.value += 1.0
            for i in range(len(ra)):
                ra[i] += 10
            print(f"Raw 값 수정: {rv.value}, 배열: {[ra[i] for i in range(len(ra))]}")
        
        processes = []
        for _ in range(2):
            p = Process(target=modify_raw, args=(raw_value, raw_array))
            processes.append(p)
            p.start()
        
        for p in processes:
            p.join()
        
        print(f"최종 Raw 값: {raw_value.value}")
        print(f"최종 Raw 배열: {[raw_array[i] for i in range(5)]}")

class SharedCounterExample:
    """공유 카운터 예제"""
    
    def __init__(self):
        """공유 카운터 초기화"""
        self.counter = Value('i', 0)
    
    def increment(self, n: int) -> None:
        """카운터 증가
        
        Args:
            n: 증가시킬 횟수
        """
        for _ in range(n):
            with self.counter.get_lock():
                self.counter.value += 1
    
    def run_workers(self, num_processes: int, increments_per_process: int) -> None:
        """여러 프로세스로 카운터 증가
        
        Args:
            num_processes: 생성할 프로세스 수
            increments_per_process: 프로세스당 증가 횟수
        """
        processes = []
        for _ in range(num_processes):
            p = Process(target=self.increment, args=(increments_per_process,))
            processes.append(p)
            p.start()
        
        for p in processes:
            p.join()
        
        expected = num_processes * increments_per_process
        print(f"예상 카운터 값: {expected}")
        print(f"실제 카운터 값: {self.counter.value}")
        print(f"정확성: {'정확함' if expected == self.counter.value else '경쟁 상태 발생'}")

# 사용 예시
if __name__ == '__main__':
    import os
    
    # 공유 메모리 예제
    print("\n===== 공유 메모리 예제 =====")
    shared_mem = SharedMemoryExample()
    
    print("\n[Value 객체 사용]")
    shared_mem.demonstrate_value()
    
    print("\n[Array 객체 사용]")
    shared_mem.demonstrate_array()
    
    print("\n[Raw 타입 사용]")
    shared_mem.demonstrate_raw_types()
    
    # 공유 카운터 예제
    print("\n===== 공유 카운터 경쟁 상태 예방 =====")
    counter = SharedCounterExample()
    counter.run_workers(num_processes=4, increments_per_process=10000)

from multiprocessing import Process, Manager, Lock
import time
import random
from typing import Dict, List, Any, Set, DefaultDict
import collections

class ManagerExample:
    """Manager 객체 사용 예제"""
    
    def worker_dict(self, shared_dict: Dict, worker_id: int, keys: List[str]) -> None:
        """공유 딕셔너리 작업 프로세스
        
        Args:
            shared_dict: 공유 딕셔너리
            worker_id: 작업자 ID
            keys: 작업할 키 목록
        """
        for key in keys:
            # 현재 값 읽기
            current = shared_dict.get(key, 0)
            # 값 업데이트
            shared_dict[key] = current + worker_id
            print(f"Worker {worker_id}: 키 '{key}' 값을 {current} → {shared_dict[key]}로 업데이트")
            time.sleep(random.random() * 0.3)  # 임의 지연
    
    def worker_list(self, shared_list: List, items: List[int]) -> None:
        """공유 리스트 작업 프로세스
        
        Args:
            shared_list: 공유 리스트
            items: 추가할 항목 목록
        """
        for item in items:
            shared_list.append(item)
            print(f"프로세스 {os.getpid()}: 항목 {item} 추가됨, 현재 리스트: {list(shared_list)}")
            time.sleep(random.random() * 0.2)  # 임의 지연
    
    def worker_namespace(self, ns: Any, worker_id: int) -> None:
        """공유 네임스페이스 작업 프로세스
        
        Args:
            ns: 공유 네임스페이스
            worker_id: 작업자 ID
        """
        # 속성 업데이트
        current = getattr(ns, f'count_{worker_id}', 0)
        setattr(ns, f'count_{worker_id}', current + 1)
        
        # 공유 total 값 업데이트
        ns.total += 1
        
        print(f"Worker {worker_id}: count_{worker_id}={getattr(ns, f'count_{worker_id}')}, total={ns.total}")
        time.sleep(0.1)
    
    def demonstrate_dict(self) -> None:
        """공유 딕셔너리 데모"""
        with Manager() as manager:
            # 공유 딕셔너리 생성
            shared_dict = manager.dict()
            shared_dict['초기값'] = 100
            
            processes = []
            all_keys = ['a', 'b', 'c', 'd', 'e']
            
            # 작업자별로 키 분배
            for i in range(3):
                keys = all_keys[i:i+3]  # 일부 키 겹침
                p = Process(target=self.worker_dict, args=(shared_dict, i+1, keys))
                processes.append(p)
                p.start()
            
            for p in processes:
                p.join()
            
            # 최종 결과 출력
            print(f"최종 딕셔너리: {dict(shared_dict)}")
    
    def demonstrate_list(self) -> None:
        """공유 리스트 데모"""
        with Manager() as manager:
            # 공유 리스트 생성
            shared_list = manager.list([0, 10, 20])
            
            processes = []
            # 여러 프로세스가 리스트에 항목 추가
            for i in range(3):
                items = list(range(i*10+1, i*10+4))
                p = Process(target=self.worker_list, args=(shared_list, items))
                processes.append(p)
                p.start()
            
            for p in processes:
                p.join()
            
            # 최종 결과 출력
            print(f"최종 리스트: {list(shared_list)}")
    
    def demonstrate_namespace(self) -> None:
        """공유 네임스페이스 데모"""
        with Manager() as manager:
            # 공유 네임스페이스 생성
            ns = manager.Namespace()
            ns.total = 0
            
            processes = []
            for i in range(1, 5):
                setattr(ns, f'count_{i}', 0)  # 초기화
                p = Process(target=self.worker_namespace, args=(ns, i))
                processes.append(p)
                p.start()
            
            for p in processes:
                p.join()
            
            # 결과 출력
            print("\n최종 네임스페이스 상태:")
            print(f"total: {ns.total}")
            for i in range(1, 5):
                print(f"count_{i}: {getattr(ns, f'count_{i}')}")
    
    def demonstrate_complex_structures(self) -> None:
        """복합 자료구조 데모"""
        with Manager() as manager:
            # 다양한 공유 컬렉션 생성
            shared_list = manager.list()
            shared_dict = manager.dict()
            shared_set = manager.set()
            
            # 바로 함수 정의
            def complex_worker(lock, list_obj, dict_obj, set_obj, worker_id):
                with lock:
                    # 모든 공유 객체 업데이트
                    list_obj.append(worker_id)
                    dict_obj[f'worker_{worker_id}'] = worker_id * 10
                    set_obj.add(worker_id * 100)
                    
                    print(f"Worker {worker_id} 업데이트:")
                    print(f"  리스트: {list(list_obj)}")
                    print(f"  딕셔너리: {dict(dict_obj)}")
                    print(f"  집합: {set(set_obj)}")
            
            # 공유 락 생성
            lock = manager.Lock()
            
            processes = []
            for i in range(1, 4):
                p = Process(target=complex_worker, args=(lock, shared_list, shared_dict, shared_set, i))
                processes.append(p)
                p.start()
            
            for p in processes:
                p.join()
            
            # 최종 결과 출력
            print("\n최종 결과:")
            print(f"리스트: {list(shared_list)}")
            print(f"딕셔너리: {dict(shared_dict)}")
            print(f"집합: {set(shared_set)}")

# 사용 예시
if __name__ == '__main__':
    import os
    
    manager_example = ManagerExample()
    
    # 딕셔너리 예제
    print("\n===== 공유 딕셔너리 예제 =====")
    manager_example.demonstrate_dict()
    
    # 리스트 예제
    print("\n===== 공유 리스트 예제 =====")
    manager_example.demonstrate_list()
    
    # 네임스페이스 예제
    print("\n===== 공유 네임스페이스 예제 =====")
    manager_example.demonstrate_namespace()
    
    # 복합 자료구조 예제
    print("\n===== 복합 자료구조 예제 =====")
    manager_example.demonstrate_complex_structures()