Python Multiprocessing: 속도를 위한 병렬 처리 가이드
- Name
- Soren Atelier
Updated on
Python의 단일 스레드 실행 모델은 대규모 데이터셋을 처리하거나 CPU 집약적 계산을 수행할 때 한계에 부딪힙니다. 데이터 처리에 10분이 걸리는 스크립트는 이론적으로 5코어 머신에서 2분 안에 실행될 수 있지만, Python의 Global Interpreter Lock(GIL)은 표준 스레드가 진정한 병렬 처리를 달성하는 것을 방지합니다. 그 결과 CPU 코어가 낭비되고 개발자들은 멀티코어 프로세서가 유휴 상태로 있는 동안 Python이 작업을 하나씩 처리하는 것을 좌절하며 지켜봅니다.
이 병목 현상은 실제 시간과 비용을 소모합니다. 데이터 과학자들은 몇 분이면 끝날 모델 학습에 몇 시간을 기다립니다. 웹 스크레이퍼는 잠재적 속도의 일부분으로 크롤링합니다. 사용 가능한 모든 코어를 활용해야 하는 이미지 처리 파이프라인이 대신 하나의 코어만 사용하며 더디게 진행됩니다.
multiprocessing 모듈은 각각 고유한 인터프리터와 메모리 공간을 가진 별도의 Python 프로세스를 생성하여 이 문제를 해결합니다. 스레드와 달리 프로세스는 GIL을 완전히 우회하여 CPU 코어 전체에서 진정한 병렬 실행을 가능하게 합니다. 이 가이드는 기본 병렬 실행부터 프로세스 풀 및 공유 메모리와 같은 고급 패턴까지 극적인 성능 향상을 위해 multiprocessing을 활용하는 방법을 보여줍니다.
GIL 문제 이해하기
Global Interpreter Lock(GIL)은 Python 객체에 대한 액세스를 보호하는 뮤텍스로, 여러 스레드가 동시에 Python 바이트코드를 실행하는 것을 방지합니다. 16코어 머신에서도 CPU 바운드 작업의 경우 Python 스레드는 한 번에 하나씩 실행됩니다.
import threading
import time
def cpu_bound_task(n):
count = 0
for i in range(n):
count += i * i
return count
# Threading은 CPU 바운드 작업을 병렬화하지 않습니다
start = time.time()
threads = [threading.Thread(target=cpu_bound_task, args=(10_000_000,)) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
print(f"Threading: {time.time() - start:.2f}s") # 싱글 스레드와 거의 같은 시간GIL은 I/O 작업(파일 읽기, 네트워크 요청) 중에만 해제되어 threading은 I/O 바운드 작업에는 유용하지만 CPU 바운드 작업에는 비효율적입니다. Multiprocessing은 별도의 Python 인터프리터를 병렬로 실행하여 GIL을 우회합니다.
Process를 사용한 기본 Multiprocessing
Process 클래스는 독립적으로 실행되는 새 Python 프로세스를 생성합니다. 각 프로세스에는 자체 메모리 공간과 Python 인터프리터가 있습니다.
from multiprocessing import Process
import os
def worker(name):
print(f"Worker {name}이(가) 프로세스 {os.getpid()}에서 실행 중")
result = sum(i*i for i in range(5_000_000))
print(f"Worker {name} 완료: {result}")
if __name__ == '__main__':
processes = []
# 4개의 프로세스 생성
for i in range(4):
p = Process(target=worker, args=(f"#{i}",))
processes.append(p)
p.start()
# 모두 완료될 때까지 대기
for p in processes:
p.join()
print("모든 프로세스 완료")중요한 요구사항: Windows와 macOS에서는 항상 if __name__ == '__main__' 가드를 사용하세요. 이것이 없으면 자식 프로세스가 재귀적으로 더 많은 프로세스를 생성하여 포크 폭탄을 일으킵니다.
Process Pool: 단순화된 병렬 실행
Pool은 워커 프로세스 풀을 관리하고 작업을 자동으로 분산합니다. 이것은 가장 일반적인 multiprocessing 패턴입니다.
from multiprocessing import Pool
import time
def process_item(x):
"""CPU 집약적 작업 시뮬레이션"""
time.sleep(0.1)
return x * x
if __name__ == '__main__':
data = range(100)
# 순차 처리
start = time.time()
results_seq = [process_item(x) for x in data]
seq_time = time.time() - start
# 4개 워커로 병렬 처리
start = time.time()
with Pool(processes=4) as pool:
results_par = pool.map(process_item, data)
par_time = time.time() - start
print(f"순차: {seq_time:.2f}s")
print(f"병렬 (4코어): {par_time:.2f}s")
print(f"가속: {seq_time/par_time:.2f}x")Pool 메서드 비교
다양한 Pool 메서드는 다양한 사용 사례에 적합합니다:
| 메서드 | 사용 사례 | 차단 | 반환 | 다중 인자 |
|---|---|---|---|---|
map() | 간단한 병렬화 | 예 | 순서 있는 리스트 | 아니오 (단일 인자) |
map_async() | 비차단 map | 아니오 | AsyncResult | 아니오 |
starmap() | 다중 인자 | 예 | 순서 있는 리스트 | 예 (튜플 언패킹) |
starmap_async() | 비차단 starmap | 아니오 | AsyncResult | 예 |
apply() | 단일 함수 호출 | 예 | 단일 결과 | 예 |
apply_async() | 비차단 apply | 아니오 | AsyncResult | 예 |
imap() | 지연 반복자 | 예 | 반복자 | 아니오 |
imap_unordered() | 지연, 순서 없음 | 예 | 반복자 | 아니오 |
from multiprocessing import Pool
def add(x, y):
return x + y
def power(x, exp):
return x ** exp
if __name__ == '__main__':
with Pool(4) as pool:
# map: 단일 인자
squares = pool.map(lambda x: x**2, [1, 2, 3, 4])
# starmap: 다중 인자 (튜플 언패킹)
results = pool.starmap(add, [(1, 2), (3, 4), (5, 6)])
# apply_async: 비차단 단일 호출
async_result = pool.apply_async(power, (2, 10))
result = async_result.get() # 준비될 때까지 차단
# imap: 대규모 데이터셋을 위한 지연 평가
for result in pool.imap(lambda x: x**2, range(1000)):
pass # 결과가 도착하는 대로 하나씩 처리프로세스 간 통신
프로세스는 기본적으로 메모리를 공유하지 않습니다. 통신을 위해 Queue 또는 Pipe를 사용하세요.
Queue: 스레드 안전 메시지 전달
from multiprocessing import Process, Queue
def producer(queue, items):
for item in items:
queue.put(item)
print(f"생산: {item}")
queue.put(None) # 센티널 값
def consumer(queue):
while True:
item = queue.get()
if item is None:
break
print(f"소비: {item}")
# 아이템 처리...
if __name__ == '__main__':
q = Queue()
items = [1, 2, 3, 4, 5]
prod = Process(target=producer, args=(q, items))
cons = Process(target=consumer, args=(q,))
prod.start()
cons.start()
prod.join()
cons.join()Pipe: 양방향 통신
from multiprocessing import Process, Pipe
def worker(conn):
conn.send("워커에서 안녕하세요")
msg = conn.recv()
print(f"워커가 받음: {msg}")
conn.close()
if __name__ == '__main__':
parent_conn, child_conn = Pipe()
p = Process(target=worker, args=(child_conn,))
p.start()
msg = parent_conn.recv()
print(f"부모가 받음: {msg}")
parent_conn.send("부모에서 안녕하세요")
p.join()공유 메모리와 상태
프로세스는 별도의 메모리를 가지지만, multiprocessing은 공유 메모리 프리미티브를 제공합니다.
Value와 Array: 공유 프리미티브
from multiprocessing import Process, Value, Array
import time
def increment_counter(counter, lock):
for _ in range(100_000):
with lock:
counter.value += 1
def fill_array(arr, start, end):
for i in range(start, end):
arr[i] = i * i
if __name__ == '__main__':
# 락이 있는 공유 값
counter = Value('i', 0)
lock = counter.get_lock()
processes = [Process(target=increment_counter, args=(counter, lock)) for _ in range(4)]
for p in processes: p.start()
for p in processes: p.join()
print(f"카운터: {counter.value}") # 400,000이어야 함
# 공유 배열
shared_arr = Array('i', 1000)
p1 = Process(target=fill_array, args=(shared_arr, 0, 500))
p2 = Process(target=fill_array, args=(shared_arr, 500, 1000))
p1.start(); p2.start()
p1.join(); p2.join()
print(f"Array[100]: {shared_arr[100]}") # 10,000Manager: 복잡한 공유 객체
from multiprocessing import Process, Manager
def update_dict(shared_dict, key, value):
shared_dict[key] = value
if __name__ == '__main__':
with Manager() as manager:
# 공유 dict, list, namespace
shared_dict = manager.dict()
shared_list = manager.list()
processes = [
Process(target=update_dict, args=(shared_dict, f"key{i}", i*10))
for i in range(5)
]
for p in processes: p.start()
for p in processes: p.join()
print(dict(shared_dict)) # {'key0': 0, 'key1': 10, ...}비교: Multiprocessing vs Threading vs Asyncio
| 기능 | Multiprocessing | Threading | Asyncio | concurrent.futures |
|---|---|---|---|---|
| GIL 우회 | 예 | 아니오 | 아니오 | 실행자에 따라 다름 |
| CPU 바운드 작업 | 탁월함 | 부족함 | 부족함 | 탁월함 (ProcessPoolExecutor) |
| I/O 바운드 작업 | 좋음 | 탁월함 | 탁월함 | 탁월함 (ThreadPoolExecutor) |
| 메모리 오버헤드 | 높음 (별도 프로세스) | 낮음 (공유 메모리) | 낮음 | 다양함 |
| 시작 비용 | 높음 | 낮음 | 매우 낮음 | 다양함 |
| 통신 | Queue, Pipe, 공유 메모리 | 직접 (공유 상태) | 네이티브 async/await | Futures |
| 최적 사용 | CPU 집약적 병렬 작업 | I/O 바운드 작업, 간단한 동시성 | 비동기 I/O, 많은 동시 작업 | 둘 다를 위한 통합 API |
# CPU 바운드에 multiprocessing 사용
from multiprocessing import Pool
def cpu_bound(n):
return sum(i*i for i in range(n))
with Pool(4) as pool:
results = pool.map(cpu_bound, [10_000_000] * 4)
# I/O 바운드에 threading 사용
import threading
import requests
def fetch_url(url):
return requests.get(url).text
threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]
for t in threads: t.start()
for t in threads: t.join()
# 비동기 I/O에 asyncio 사용
import asyncio
import aiohttp
async def fetch_async(url):
async with aiohttp.ClientSession() as session:
async with session.get(url) as response:
return await response.text()
asyncio.run(asyncio.gather(*[fetch_async(url) for url in urls]))고급: ProcessPoolExecutor
concurrent.futures.ProcessPoolExecutor는 ThreadPoolExecutor와 동일한 API를 가진 고수준 인터페이스를 제공합니다.
from concurrent.futures import ProcessPoolExecutor, as_completed
import time
def process_task(x):
time.sleep(0.1)
return x * x
if __name__ == '__main__':
# 컨텍스트 매니저가 정리를 보장
with ProcessPoolExecutor(max_workers=4) as executor:
# 개별 작업 제출
futures = [executor.submit(process_task, i) for i in range(20)]
# 완료되는 대로 처리
for future in as_completed(futures):
result = future.result()
print(f"결과: {result}")
# 또는 map 사용 (Pool.map처럼)
results = executor.map(process_task, range(20))
print(list(results))Pool에 비한 장점:
ThreadPoolExecutor와ProcessPoolExecutor에 동일한 API- 더 많은 제어를 위한 Futures 인터페이스
- 더 나은 오류 처리
- 동기 및 비동기 코드 혼합이 더 쉬움
일반적인 패턴
당황스러울 정도로 병렬한 작업
종속성이 없는 작업은 multiprocessing에 이상적입니다:
from multiprocessing import Pool
import pandas as pd
def process_chunk(chunk):
"""데이터 청크를 독립적으로 처리"""
chunk['new_col'] = chunk['value'] * 2
return chunk.groupby('category').sum()
if __name__ == '__main__':
df = pd.DataFrame({'category': ['A', 'B'] * 5000, 'value': range(10000)})
# 청크로 분할
chunks = [df.iloc[i:i+2500] for i in range(0, len(df), 2500)]
with Pool(4) as pool:
results = pool.map(process_chunk, chunks)
# 결과 결합
final = pd.concat(results).groupby('category').sum()Map-Reduce 패턴
from multiprocessing import Pool
from functools import reduce
def mapper(text):
"""Map: 단어 추출 및 카운트"""
words = text.lower().split()
return {word: 1 for word in words}
def reducer(dict1, dict2):
"""Reduce: 단어 카운트 병합"""
for word, count in dict2.items():
dict1[word] = dict1.get(word, 0) + count
return dict1
if __name__ == '__main__':
documents = ["안녕 세상", "파이썬의 세상", "안녕 파이썬"] * 1000
with Pool(4) as pool:
# Map 단계: 병렬
word_dicts = pool.map(mapper, documents)
# Reduce 단계: 순차 (또는 트리 축소 사용)
word_counts = reduce(reducer, word_dicts)
print(word_counts)다중 Producer를 사용한 Producer-Consumer
from multiprocessing import Process, Queue, cpu_count
def producer(queue, producer_id, items):
for item in items:
queue.put((producer_id, item))
print(f"Producer {producer_id} 완료")
def consumer(queue, num_producers):
finished_producers = 0
while finished_producers < num_producers:
if not queue.empty():
item = queue.get()
if item is None:
finished_producers += 1
else:
producer_id, data = item
print(f"Producer {producer_id}에서 소비: {data}")
if __name__ == '__main__':
q = Queue()
num_producers = 3
# Producer 시작
producers = [
Process(target=producer, args=(q, i, range(i*10, (i+1)*10)))
for i in range(num_producers)
]
for p in producers: p.start()
# Consumer 시작
cons = Process(target=consumer, args=(q, num_producers))
cons.start()
# 정리
for p in producers: p.join()
for _ in range(num_producers):
q.put(None) # Consumer에게 신호
cons.join()성능 고려사항
Multiprocessing이 도움이 되는 경우
- CPU 바운드 작업: 데이터 처리, 수학 계산, 이미지 처리
- 대규모 데이터셋: 아이템당 처리 시간이 프로세스 오버헤드를 정당화하는 경우
- 독립적 작업: 공유 상태가 없거나 최소한의 통신
Multiprocessing이 해가 되는 경우
프로세스 생성 오버헤드가 이점을 초과할 수 있는 경우:
from multiprocessing import Pool
import time
def tiny_task(x):
return x + 1
if __name__ == '__main__':
data = range(100)
# 작은 작업에는 순차가 더 빠름
start = time.time()
results = [tiny_task(x) for x in data]
print(f"순차: {time.time() - start:.4f}s") # ~0.0001s
start = time.time()
with Pool(4) as pool:
results = pool.map(tiny_task, data)
print(f"병렬: {time.time() - start:.4f}s") # ~0.05s (500배 느림!)경험칙:
- 최소 작업 기간: 아이템당 약 0.1초
- 데이터 크기: 데이터를 피클링하는 시간이 처리보다 오래 걸리면 공유 메모리 사용
- 워커 수:
cpu_count()로 시작하여 작업 특성에 따라 조정
Pickling 요구사항
프로세스 간에 전달할 수 있는 것은 피클 가능한 객체뿐입니다:
from multiprocessing import Pool
# ❌ 람다 함수는 피클 불가능
# pool.map(lambda x: x*2, range(10)) # 실패
# ✅ 명명된 함수 사용
def double(x):
return x * 2
with Pool(4) as pool:
pool.map(double, range(10))
# ❌ 노트북의 로컬 함수는 실패
# def process():
# def inner(x): return x*2
# pool.map(inner, range(10)) # 실패
# ✅ 모듈 레벨에서 정의하거나 functools.partial 사용
from functools import partial
def multiply(x, factor):
return x * factor
with Pool(4) as pool:
pool.map(partial(multiply, factor=3), range(10))RunCell로 병렬 코드 디버그하기
multiprocessing 코드 디버깅은 악명 높게 어렵습니다. print 문이 사라지고, 중단점이 작동하지 않으며, 스택 트레이스가 암호 같습니다. 프로세스가 조용히 충돌하거나 잘못된 결과를 생성할 때 전통적인 디버깅 도구는 실패합니다.
RunCell(www.runcell.dev)은 (opens in a new tab) 병렬 코드 디버깅에 뛰어난 Jupyter용 AI 에이전트입니다. 프로세스 간 실행을 추적할 수 없는 표준 디버거와 달리 RunCell은 multiprocessing 패턴을 분석하고, 경쟁 조건을 식별하며, 런타임 전에 피클링 오류를 감지하고, 프로세스가 교착 상태에 빠지는 이유를 설명합니다.
Pool 워커가 트레이스백 없이 충돌하면 RunCell은 오류 큐를 검사하여 어떤 함수 호출이 실패했는지, 왜 그런지 정확히 보여줄 수 있습니다. 공유 상태가 잘못된 결과를 생성하면 RunCell은 메모리 액세스 패턴을 추적하여 누락된 락을 찾습니다. 복잡한 병렬 데이터 파이프라인을 디버깅하는 데이터 과학자에게 RunCell은 몇 시간의 print 문 디버깅을 AI 가이드 수정의 몇 분으로 바꿉니다.
모범 사례
1. 항상 if name 가드 사용
# ✅ 올바름
if __name__ == '__main__':
with Pool(4) as pool:
pool.map(func, data)
# ❌ 잘못됨 - Windows에서 포크 폭탄 발생
with Pool(4) as pool:
pool.map(func, data)2. Pool을 명시적으로 닫기
# ✅ 컨텍스트 매니저 (권장)
with Pool(4) as pool:
results = pool.map(func, data)
# ✅ 명시적 close 및 join
pool = Pool(4)
results = pool.map(func, data)
pool.close()
pool.join()
# ❌ 리소스 누수
pool = Pool(4)
results = pool.map(func, data)3. 예외 처리
from multiprocessing import Pool
def risky_task(x):
if x == 5:
raise ValueError("잘못된 값")
return x * 2
if __name__ == '__main__':
with Pool(4) as pool:
try:
results = pool.map(risky_task, range(10))
except ValueError as e:
print(f"작업 실패: {e}")
# 또는 apply_async로 개별 처리
async_results = [pool.apply_async(risky_task, (i,)) for i in range(10)]
for i, ar in enumerate(async_results):
try:
result = ar.get()
print(f"결과 {i}: {result}")
except ValueError:
print(f"작업 {i} 실패")4. 가능한 경우 공유 상태 피하기
# ❌ 공유 상태는 동기화 필요
from multiprocessing import Process, Value
counter = Value('i', 0)
def increment():
for _ in range(100000):
counter.value += 1 # 경쟁 조건!
# ✅ 락 사용 또는 공유 피하기
from multiprocessing import Lock
lock = Lock()
def increment_safe():
for _ in range(100000):
with lock:
counter.value += 1
# ✅ 더 나음: 공유 상태 피하기
def count_locally(n):
return n # 대신 결과 반환
with Pool(4) as pool:
results = pool.map(count_locally, [100000] * 4)
total = sum(results)5. 올바른 워커 수 선택
from multiprocessing import cpu_count, Pool
# CPU 바운드: 모든 코어 사용
num_workers = cpu_count()
# I/O 바운드: 더 많은 워커 사용 가능
num_workers = cpu_count() * 2
# 혼합 워크로드: 경험적으로 조정
with Pool(processes=num_workers) as pool:
results = pool.map(func, data)일반적인 실수
1. if name 가드 잊어버리기
Windows/macOS에서 무한 프로세스 생성으로 이어집니다.
2. 피클 불가능한 객체를 피클링하려고 시도
# ❌ 클래스 메서드, 람다, 로컬 함수는 실패
class DataProcessor:
def process(self, x):
return x * 2
dp = DataProcessor()
# pool.map(dp.process, data) # 실패
# ✅ 최상위 함수 사용
def process(x):
return x * 2
with Pool(4) as pool:
pool.map(process, data)3. 프로세스 종료 처리 안 함
# ❌ 제대로 정리하지 않음
pool = Pool(4)
results = pool.map(func, data)
# pool이 여전히 실행 중
# ✅ 항상 close 및 join
pool = Pool(4)
try:
results = pool.map(func, data)
finally:
pool.close()
pool.join()4. 과도한 데이터 전송
# ❌ 거대한 객체 피클링은 느림
large_data = [np.random.rand(1000, 1000) for _ in range(100)]
with Pool(4) as pool:
pool.map(process_array, large_data) # 느린 직렬화
# ✅ 공유 메모리 또는 메모리 맵 파일 사용
import numpy as np
from multiprocessing import shared_memory
# 공유 메모리 생성
shm = shared_memory.SharedMemory(create=True, size=1000*1000*8)
arr = np.ndarray((1000, 1000), dtype=np.float64, buffer=shm.buf)
# 이름과 형태만 전달
def process_shared(name, shape):
existing_shm = shared_memory.SharedMemory(name=name)
arr = np.ndarray(shape, dtype=np.float64, buffer=existing_shm.buf)
# arr 처리...
existing_shm.close()
with Pool(4) as pool:
pool.starmap(process_shared, [(shm.name, (1000, 1000))] * 4)
shm.close()
shm.unlink()FAQ
multiprocessing은 어떻게 GIL을 우회하나요?
GIL(Global Interpreter Lock)은 각 Python 인터프리터의 뮤텍스로, 여러 스레드가 동시에 Python 바이트코드를 실행하는 것을 방지합니다. Multiprocessing은 각각 고유한 인터프리터와 GIL을 가진 별도의 Python 프로세스를 생성하여 이를 우회합니다. 프로세스는 메모리를 공유하지 않으므로 GIL 경합 없이 CPU 코어 전체에서 진정으로 병렬로 실행됩니다.
multiprocessing과 threading은 언제 사용해야 하나요?
GIL이 성능을 제한하는 CPU 바운드 작업(데이터 처리, 계산, 이미지 조작)에는 multiprocessing을 사용하세요. I/O 중에 GIL이 해제되는 I/O 바운드 작업(네트워크 요청, 파일 작업)에는 threading을 사용하여 스레드가 동시에 작동할 수 있도록 하세요. Threading은 오버헤드가 낮지만 GIL 때문에 CPU 작업을 병렬화할 수 없습니다.
왜 if name == 'main' 가드가 필요한가요?
Windows와 macOS에서 자식 프로세스는 함수에 액세스하기 위해 메인 모듈을 가져옵니다. 가드가 없으면 모듈을 가져오는 것이 Pool 생성 코드를 다시 실행하여 무한 프로세스(포크 폭탄)를 생성합니다. Linux는 가져오기가 필요하지 않은 fork()를 사용하지만 크로스 플랫폼 코드의 모범 사례로 가드가 여전히 필요합니다.
몇 개의 워커 프로세스를 사용해야 하나요?
CPU 바운드 작업의 경우 cpu_count()(CPU 코어 수)로 시작하세요. 코어보다 많은 워커는 컨텍스트 스위칭 오버헤드를 발생시킵니다. I/O 바운드 작업의 경우 프로세스가 I/O를 기다리므로 더 많은 워커(2-4배 코어)를 사용할 수 있습니다. 메모리 및 데이터 전송 오버헤드가 최적 워커 수를 제한할 수 있으므로 항상 특정 워크로드로 벤치마크하세요.
multiprocessing 함수에 어떤 객체를 전달할 수 있나요?
객체는 피클 가능(pickle로 직렬화 가능)해야 합니다. 여기에는 내장 타입(int, str, list, dict), NumPy 배열, pandas DataFrame 및 대부분의 사용자 정의 클래스가 포함됩니다. 람다, 로컬 함수, 클래스 메서드, 파일 핸들, 데이터베이스 연결 및 스레드 락은 피클링할 수 없습니다. 모듈 레벨에서 함수를 정의하거나 부분 적용을 위해 functools.partial을 사용하세요.
결론
Python multiprocessing은 CPU 바운드 병목 현상을 사용 가능한 코어에 따라 확장되는 병렬 작업으로 변환합니다. 별도의 프로세스를 통해 GIL을 우회함으로써 threading으로는 불가능한 진정한 병렬 처리를 달성합니다. Pool 인터페이스는 일반적인 패턴을 단순화하고 Queue, Pipe 및 공유 메모리는 복잡한 프로세스 간 워크플로를 가능하게 합니다.
당황스러울 정도로 병렬한 작업에는 Pool.map()으로 시작하고, 속도 향상을 측정하고, 거기서부터 최적화하세요. if __name__ == '__main__' 가드를 기억하고, 프로세스 오버헤드를 상쇄하기 위해 작업을 거칠게 유지하며, 프로세스 간 데이터 전송을 최소화하세요. 디버깅이 복잡해지면 RunCell과 같은 도구가 프로세스 경계를 넘어 실행을 추적하는 데 도움이 될 수 있습니다.
Multiprocessing이 항상 답은 아닙니다. I/O 바운드 작업의 경우 threading이나 asyncio가 더 간단하고 빠를 수 있습니다. 그러나 대규모 데이터셋을 처리하거나 모델을 훈련하거나 무거운 계산을 수행할 때 multiprocessing은 멀티코어 머신이 구축된 목적인 성능을 제공합니다.