Python: Parallelism Vs Concurrency Vs Threading (opens new window)์ ์ฝ๊ณ ์ ๋ฆฌํ์์ต๋๋ค.
์ฌ๋ฌ ์์ ์ ๊ด๋ฆฌํ๊ณ , ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ํํ๋ฉฐ, ๋ ๋ฆฝ์ ์ธ ์ํฌํ๋ก์ฐ๋ฅผ ๋ณด์ฅํ๋ ค๋ฉด ๋์์ฑ(Concurrency), ์ค๋ ๋ฉ(Threading), ๋ณ๋ ฌ ์ฒ๋ฆฌ(Parallelism)๋ฅผ ์ดํดํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ฒ์์๋ ์ด ๊ฐ๋ ๋ค์ด ๋น์ทํ๊ฒ ๋๊ปด์ง ์ ์์ง๋ง ์๋ก ์ฐจ์ด๊ฐ ์์ต๋๋ค. ์ด๋ฒ ๊ธ์์๋ ๋ง์น ์นดํ๊ฐ ์ง์๊ณผ ์ฅ๋น๋ฅผ ๊ด๋ฆฌํ๋ ๋ฐฉ์์ ์์๋ก ์ค๋ช ํฉ๋๋ค.
์ด ๊ธ์์๋ ๊ธฐ์ ์ ์ธ ๊ฐ๋ ์ ์ ๊ทผํ๊ธฐ ์ฝ๊ฒ ํ๊ธฐ ์ํด ์นดํ ์๋๋ฆฌ์ค๋ฅผ ํตํด ์ด๋ฌํ ํจ๋ฌ๋ค์์ ํ๊ตฌํ ๊ฒ์ ๋๋ค. ๋ํ Python์ ๊ฐ๋ ฅํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ธ asyncio, threading, multiprocessing์ ํ์ฉํ ์์๋ ํ์ธํฉ๋๋ค. ๋จ์ผ ์ค๋ ๋๋ฅผ ๊ด๋ฆฌํ๋ , ๋ค์ค ์ฝ์ด๋ฅผ ํ์ฉํ๋ , ์ด ๊ฐ๋ ์ ํจ๊ณผ์ ์ผ๋ก ํ๋ก์ ํธ์ ์ ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ ๋ช ํํ ์ดํดํ ์ ์์ ๊ฒ์ ๋๋ค.
Concurrency(๋์์ฑ)๐
ํผ์ ์ด์ํ๋ ์นดํ๋ฅผ ์์ํด๋ณด์ธ์. ํ ๊ณ ๊ฐ์ ์ปคํผ๋ฅผ ์ถ์ถํ๋ ๋์, ๋ค๋ฅธ ๊ณ ๊ฐ์ ์ฃผ๋ฌธ์ ๋ฐ๊ณ , ์ฐ์ ๋ฅผ ์คํํ๊ณ , ๋ ๋ค๋ฅธ ๊ณ ๊ฐ์ ์๋์์น๋ฅผ ์ค๋นํฉ๋๋ค.
ํ ๋ฒ์ ๋ชจ๋ ์์ ์ ํ์ง ์์ง๋ง, ์์ ๊ฐ ์ ํ์ ํตํด ๋ชจ๋ ์ฃผ๋ฌธ์ ํจ์จ์ ์ผ๋ก ์งํ์ํต๋๋ค.
โก๏ธ Python์์ ๊ตฌํ ๋ฐฉ๋ฒ:
import asyncio
async def task(name, delay):
print(f"{name} started")
await asyncio.sleep(delay)
print(f"{name} completed")
async def main():
task1 = asyncio.create_task(task("Task1", 2))
task2 = asyncio.create_task(task("Task2", 3))
print("Tasks are running concurrently...")
await task1
await task2
print("Both tasks are completed")
asyncio.run(main())
๋์์ฑ์ asyncio ๊ฐ์ ํจํค์ง๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ์์ ์ ๋์์ ์ํํ์ง ์๋๋ผ๋ ์์ ๊ฐ ์ ํ์ ํตํด ์ฌ๋ฌ ์์ ์ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํฉ๋๋ค.
Threading(์ค๋ ๋ฉ) ๐งต
๋ถ์ฃผํ ์ปคํผ์์ ์ด์ํ๋ค๊ณ ์์ํด๋ณด์ธ์. ์ฌ๋ฌ ๋ช ์ ์์ ์ด ๋ณต์ ๋์ด ๊ฐ๊ธฐ ๋ค๋ฅธ ์์ ์ ์ง์คํฉ๋๋ค. ํ ์ฌ๋์ ์ปคํผ๋ฅผ ์ถ์ถํ๊ณ , ๋ค๋ฅธ ์ฌ๋์ ํ์ด์คํธ๋ฆฌ๋ฅผ ์ค๋นํ๋ฉฐ, ๋ ๋ค๋ฅธ ์ฌ๋์ ์ค๋ฌด๋๋ฅผ ๋ง๋ญ๋๋ค.
์ด ๋ณต์ ๋ ์์ (์ค๋ ๋)์ ๊ฐ์์ ์์ ์ ๋ ๋ฆฝ์ ์ผ๋ก ์ํํ์ง๋ง, ๋ชจ๋ ๊ฐ์ ๊ณต๊ฐ๊ณผ ์ฅ๋น๋ฅผ ๊ณต์ ํ๊ธฐ ๋๋ฌธ์ ๊ฐํน ๋๊ธฐ ์ํ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
โก๏ธ Python์์ ๊ตฌํ ๋ฐฉ๋ฒ:
import threading
import time
def task(name, delay):
print(f"{name} started")
time.sleep(delay)
print(f"{name} completed")
if __name__ == '__main__':
thread1 = threading.Thread(target=task, args=('Thread1', 2))
thread2 = threading.Thread(target=task, args=('Thread2', 3))
print("Threads are running concurrently...")
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print("Both Threads completed")
์ค๋ ๋ฉ์ ํ๋ก๊ทธ๋จ์ ๋ค๋ฅธ ๋ถ๋ถ์ ๋ณ๋ ์ค๋ ๋๋ก ์คํ์์ผ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ์ ์์์ ๊ณต์ ํ๋๋ก ํฉ๋๋ค. ์์ ์ ๋์์ ์คํ๋์ง๋ง, ์ค์ ๋ก๋ CPU๊ฐ ์ค๋ ๋ ๊ฐ์ ์ ํํ์ฌ ์คํํ๊ธฐ ๋๋ฌธ์ ์์ ํ ๋์์ ์คํ๋์ง๋ ์์ ์ ์์ต๋๋ค.
Parallelism(๋ณ๋ ฌ ์ฒ๋ฆฌ) ๐๏ธ
๊ฐ์ ์๋ฒฝํ ์ฅ๋น๋ฅผ ๊ฐ์ถ ์ฌ๋ฌ ๋ฐ๋ฆฌ์คํ๊ฐ ์๋ ๋ํ ์นดํ๋ฅผ ์์ํด๋ณด์ธ์. ํ ๋ฐ๋ฆฌ์คํ๋ ์ปคํผ๋ฅผ ๋ง๋ค๊ณ , ๋ ๋ค๋ฅธ ๋ฐ๋ฆฌ์คํ๋ ์ค๋ฌด๋๋ฅผ ๋ธ๋ ๋ฉํ๋ฉฐ, ์ธ ๋ฒ์งธ ๋ฐ๋ฆฌ์คํ๋ ์๋์์น๋ฅผ ์ค๋นํฉ๋๋ค.
๊ฐ ๋ฐ๋ฆฌ์คํ๋ ์์ ์ ์์์ ๊ฐ์ง๊ณ ๋ ๋ฆฝ์ ์ผ๋ก ์์ ํ๋ฏ๋ก ์๋ก ๊ธฐ๋ค๋ฆฌ๊ฑฐ๋ ๊ฐ์ญํ์ง ์๊ณ ๋์์ ๊ณ ๊ฐ์ ์๋ํ ์ ์์ต๋๋ค.
โก๏ธ Python์์ ๊ตฌํ ๋ฐฉ๋ฒ:
import multiprocessing
import time
def task(name, delay):
print(f"{name} started")
time.sleep(delay)
print(f"{name} completed")
if __name__ == '__main__':
process1 = multiprocessing.Process(target=task, args=("Process 1", 2))
process2 = multiprocessing.Process(target=task, args=("Process 2", 3))
print("Processes are running in parallel...")
process1.start()
process2.start()
process1.join()
process2.join()
print("Both processes completed")
๋ณ๋ ฌ ์ฒ๋ฆฌ๋ ์ฌ๋ฌ CPU ์ฝ์ด๋ฅผ ์ฌ์ฉํ์ฌ ์ค์ ๋ก ์ฌ๋ฌ ์์ ์ ๋์์ ์คํํฉ๋๋ค. multiprocessing ๊ฐ์ ํจํค์ง๋ ๋ณ๋ ํ๋ก์ธ์ค๋ฅผ ์์ฑํ์ฌ ํ๋ก์ธ์๋ฅผ ๋ถ๋ฆฌ๋ ์ฝ์ด์์ ๋ ๋ฆฝ์ ์ผ๋ก ์คํํ๋๋ก ํฉ๋๋ค.
๐ง ๋์์ฑ๊ณผ ์ค๋ ๋ฉ์ ์ฐจ์ด์ :
โก๏ธ ๋์์ฑ: ์ฌ๋ฌ ์์
์ ์ฒ๋ฆฌํ๋ ์๋ฆฌ์ฌ๊ฐ ๊ฐ ์์
๊ฐ ์ ํํ๋ฉฐ ์งํํฉ๋๋ค.
โก๏ธ ์ค๋ ๋ฉ: ์ฌ๋ฌ ์๋ฆฌ์ฌ(์ค๋ ๋)๊ฐ ๋์์ ์์
ํ์ง๋ง ๋์ผํ ์ฃผ๋ฐฉ ์์์ ๊ณต์ ํฉ๋๋ค.
๋์์ฑ์ ์์ ์ ๊ด๋ฆฌํ๊ณ ์ ํํ๋ ๋ฐฉ์์ ์ด์ ์ ๋ง์ถ๋ ๋ฐ๋ฉด, ์ค๋ ๋ฉ์ ์์ ์ ์ฌ๋ฌ ์ค๋ ๋๋ก ๋๋ ๋์์ฑ์ ๊ตฌํํ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋๋ค.
๊ฒฐ๋ก
๋์์ฑ, ์ค๋ ๋ฉ, ๋ณ๋ ฌ ์ฒ๋ฆฌ ์ค ๋ฌด์์ ์ ํํ ์ง๋ ์์ ์ ํน์ฑ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค.
- ๋์์ฑ (asyncio): CPU ๋ถํ๊ฐ ์ ์ I/O ์ค์ฌ ์์ ์ ์ ํฉ.
- ์ค๋ ๋ฉ: ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ณต์ ํ๋ฉฐ, CPU ์ง์ฝ์ ์ด์ง ์์ ์์ ์ ์ ํฉ.
- ๋ณ๋ ฌ ์ฒ๋ฆฌ (multiprocessing): CPU ์ง์ฝ์ ์์ ์ ์ ํฉํ๋ฉฐ, ์ค์ ๋ก ๋์ ์คํ์ด ํ์ํ ๋ ์ฌ์ฉ.
์ด ์ฐจ์ด๋ฅผ ์ดํดํ๋ฉด ์์์ ํจ์จ์ ์ผ๋ก ํ์ฉํ๊ณ ํ๋ก๊ทธ๋จ ์ฑ๋ฅ์ ์ต์ ํํ ์ ์์ต๋๋ค.
'note' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| PySpark ํ๋ก๋์ ํ๊ฒฝ์์ OutOfMemory(OOM) ๋ฌธ์ ํด๊ฒฐํ๊ธฐ (0) | 2024.12.12 |
|---|---|
| SparkSession๊ณผ SparkContext ์ดํดํ๊ธฐ (0) | 2024.12.04 |
| ์์ ๋ก ์ดํด๋ณด๋ AI๋ฅผ ์ํ ๋ฐ์ดํฐ ์์ง๋์ด๋ง (0) | 2024.11.30 |
| Kubernetes HPA (Horizontal Pod Autoscaler) ์์๋ณด๊ธฐ (0) | 2024.11.27 |
| Spark ์กฐ์ธ(join) ์ต์ ํ (0) | 2024.11.26 |