동시성과 병렬성: 스레드, 락, 비동기

여러 일을 번갈아 진행하는 동시성과 정말로 동시에 실행하는 병렬성을 구별해요. 스레드 열 개가 잔액을 동시에 고치다 출금이 사라지는 경쟁 상태를 재현하고 락으로 고친 뒤, 락을 반대 순서로 잡으면 서로를 영원히 기다리는 교착 상태와 그 해법을 확인해요. 파이썬의 GIL 때문에 기다리는 일은 스레드로 10배 빨라지지만 계산하는 일은 그대로인 이유, 요청 1,000개를 0.1초 남짓에 처리하는 asyncio와 그 안에서 막는 호출을 쓰면 생기는 일까지 실험해요.

고급강의 4 / 6약 13분

지금까지의 프로그램은 한 번에 한 가지 일을 했어요. 하지만 웹 서버는 수천 명의 요청을 함께 받고, 컴퓨터에는 코어가 여러 개 있어요. 이번 강의에서는 여러 일을 함께 다루는 방법을 배워요. 이 분야는 실수하기 쉽고, 실수가 가끔만 드러나서 찾기도 어려워요. 그래서 문제를 실험으로 먼저 눈앞에 꺼내 놓고 갈게요.

동시성과 병렬성은 달라요

  • 동시성: 여러 일을 번갈아 가며 조금씩 진행해서 함께 다루는 거예요. 요리사 한 명이 국이 끓는 동안 채소를 써는 모습이에요. 코어가 하나여도 돼요.
  • 병렬성: 여러 일을 정말로 같은 순간에 실행하는 거예요. 요리사가 여러 명인 모습이에요. 코어가 여러 개 있어야 해요.

동시성은 구조의 문제(여러 일을 어떻게 나눠 다룰까)이고, 병렬성은 실행의 문제(정말 동시에 돌릴까)예요. 기다리는 시간이 많은 일(네트워크, 디스크)은 동시성만으로도 크게 빨라지고, 계산이 많은 일은 병렬성이 있어야 빨라져요.

경쟁 상태: 사라지는 출금

스레드는 한 프로세스 안에서 메모리를 함께 쓰며 따로 실행되는 흐름이에요(컴퓨터 기초 트랙의 운영체제 강의). 메모리를 함께 쓰니 편하지만, 바로 그래서 위험해요. 스레드 10개가 잔액 1,000원에서 1원씩 100번씩, 모두 1,000번 출금해 볼게요.

import threading
import time

balance = 1_000

def withdraw_unsafe(times):
    global balance
    for _ in range(times):
        current = balance                            # 1. 잔액을 읽고
        time.sleep(0)                                # (여기서 다른 스레드에게 차례가 넘어갈 수 있어요)
        balance = current - 1                        # 2. 하나 뺀 값을 써요

def run(target, n_threads=10, times=100):
    threads = [threading.Thread(target=target, args=(times,)) for _ in range(n_threads)]
    for t in threads:
        t.start()
    for t in threads:
        t.join()

run(withdraw_unsafe)
print("1,000번 출금한 뒤 잔액이 0인가요?", balance == 0, "| 사라진 출금이 있나요?", balance > 0)

balance, lock = 1_000, threading.Lock()

def withdraw_safe(times):
    global balance
    for _ in range(times):
        with lock:                                   # 읽고 쓰는 동안 다른 스레드는 기다려요
            current = balance
            time.sleep(0)
            balance = current - 1

run(withdraw_safe)
print("락을 쓰면 잔액이 0인가요?", balance == 0)
1,000번 출금한 뒤 잔액이 0인가요? False | 사라진 출금이 있나요? True
락을 쓰면 잔액이 0인가요? True

1,000번을 뺐는데 잔액이 0이 아니에요. 출금 일부가 사라졌어요. 두 스레드가 같은 잔액(예를 들어 500원)을 읽고 각자 499원을 쓰면 출금 두 번이 한 번으로 줄어요. 읽기와 쓰기 사이에 다른 스레드가 끼어들 틈이 있기 때문이에요. 이렇게 실행 순서에 따라 결과가 달라지는 상황을 경쟁 상태라고 해요. 데이터베이스 트랙의 트랜잭션 강의에서 마지막 재고 하나가 두 사람에게 팔리던 것과 같은 모양이에요.

여기서는 일부러 time.sleep(0)으로 틈을 벌렸지만, 실제로는 이 틈이 아주 드물게만 맞아떨어져요. 그래서 테스트에서는 멀쩡하다가 운영 중에 가끔 숫자가 안 맞는 식으로 나타나고, 찾기가 정말 어려워요.

락(lock)으로 고쳐요. with lock: 안에는 한 번에 한 스레드만 들어갈 수 있어서, 한 스레드가 읽고 쓰는 동안 다른 스레드는 기다려요. 이렇게 한 스레드만 들어가야 하는 구간을 임계 구역이라고 해요.

교착 상태: 서로를 영원히 기다리기

락이 여러 개면 새로운 문제가 생겨요. A 계좌에서 B로 이체하는 스레드는 A의 락을 잡고 B의 락을 기다리는데, 동시에 B에서 A로 이체하는 스레드가 B의 락을 잡고 A의 락을 기다리면 어떻게 될까요? 정말 영원히 기다리면 실험이 끝나지 않으니, 0.5초만 기다리고 포기하게 했어요.

lock_a, lock_b = threading.Lock(), threading.Lock()
results = {}

def transfer(name, first, second, both_holding):
    with first:
        both_holding.wait()                          # 둘 다 첫 번째 락을 잡을 때까지 기다렸다가
        got = second.acquire(timeout=0.5)            # 두 번째 락을 기다려요(0.5초 뒤 포기)
        results[name] = got
        if got:
            second.release()

def try_both(order_ab, order_ba, both_holding):
    results.clear()
    t1 = threading.Thread(target=transfer, args=("A→B", *order_ab, both_holding))
    t2 = threading.Thread(target=transfer, args=("B→A", *order_ba, both_holding))
    t1.start()
    t2.start()
    t1.join()
    t2.join()
    return f"A→B 이체 {'성공' if results['A→B'] else '포기'}, B→A 이체 {'성공' if results['B→A'] else '포기'}"

print("반대 순서로 잡으면:", try_both((lock_a, lock_b), (lock_b, lock_a), threading.Barrier(2)))
print("같은 순서로 잡으면:", try_both((lock_a, lock_b), (lock_a, lock_b), threading.Barrier(1)))
반대 순서로 잡으면: A→B 이체 포기, B→A 이체 포기
같은 순서로 잡으면: A→B 이체 성공, B→A 이체 성공

반대 순서로 락을 잡으니 둘 다 상대가 쥔 락을 기다리다 포기했어요. 포기하지 않았다면 프로그램이 영원히 멈췄을 거예요. 이게 교착 상태(데드락)예요. 가장 확실한 해법은 락을 잡는 순서를 정해 두는 것이에요. 모든 스레드가 늘 A 다음 B 순서로 잡으면, 먼저 A를 잡은 쪽이 B까지 잡고 일을 마칠 때까지 다른 쪽은 A 앞에서 기다리니 서로 엇갈리지 않아요. 계좌 번호가 작은 쪽부터 잡는 식으로 규칙을 정하면 돼요. 그 밖에 락을 쥐는 시간을 짧게 하고, 기다리는 시간에 한계를 두는 것도 도움이 돼요.

파이썬의 GIL: 기다리는 일과 계산하는 일

파이썬(CPython)에는 GIL(전역 인터프리터 락)이 있어서, 한 순간에 파이썬 코드를 실행하는 스레드는 하나뿐이에요. 대신 스레드가 네트워크나 디스크를 기다리는 동안에는 GIL을 내려놓아요. 그래서 기다리는 일과 계산하는 일이 다르게 움직여요.

from concurrent.futures import ThreadPoolExecutor

def fake_download(i):                                # 네트워크를 기다리는 일: CPU는 놀아요
    time.sleep(0.1)
    return i

def count_up(n):                                     # 계산만 하는 일: CPU가 쉬지 않아요
    total = 0
    for i in range(n):
        total += i
    return total

def elapsed(func, jobs, workers):
    start = time.perf_counter()
    if workers == 1:
        for j in jobs:
            func(j)
    else:
        with ThreadPoolExecutor(workers) as pool:
            list(pool.map(func, jobs))
    return time.perf_counter() - start

io_seq, io_thr = elapsed(fake_download, range(10), 1), elapsed(fake_download, range(10), 10)
cpu_seq, cpu_thr = elapsed(count_up, [2_000_000] * 4, 1), elapsed(count_up, [2_000_000] * 4, 4)
print("기다리는 일 10개: 스레드로 5배 넘게 빨라졌나요?", io_seq / io_thr > 5)
print("계산하는 일 4개: 스레드 4개로 1.5배 넘게 빨라졌나요?", cpu_seq / cpu_thr > 1.5)
기다리는 일 10개: 스레드로 5배 넘게 빨라졌나요? True
계산하는 일 4개: 스레드 4개로 1.5배 넘게 빨라졌나요? False

0.1초씩 기다리는 다운로드 10개는 차례로 하면 1초, 스레드 10개로 하면 0.1초 남짓이에요. 기다리는 동안 다른 스레드가 일하니까요. 반면 계산만 하는 일 4개는 스레드 4개로 나눠도 빨라지지 않아요. 코어가 여러 개여도 GIL 때문에 파이썬 코드는 한 번에 하나씩만 돌거든요. 계산을 정말 병렬로 하려면 방법이 몇 가지 있어요.

  • 프로세스를 여러 개 쓰기: concurrent.futures.ProcessPoolExecutor나 multiprocessing은 프로세스마다 GIL을 따로 가져서 코어를 모두 써요. 대신 프로세스끼리 데이터를 주고받는 비용이 들어요.
  • GIL을 놓는 라이브러리 쓰기: 넘파이 같은 라이브러리는 큰 계산을 C로 하면서 GIL을 내려놓아서, 스레드로도 병렬 효과를 볼 수 있어요.
  • GIL 없는 파이썬 쓰기: 3.13부터 GIL을 뺀 실험판이 나왔고, 3.14부터는 공식 지원 대상이 됐어요(기본 설치판에는 아직 GIL이 있어요). 이 판에서는 위의 계산도 스레드로 빨라지는 대신, 경쟁 상태를 조심해야 할 곳이 더 늘어나요.

asyncio: 한 스레드로 수천 개를 기다리기

스레드는 하나하나가 메모리를 쓰고 운영체제가 바꿔 가며 돌려야 해서(운영체제 심화 강의의 문맥 교환), 수만 개를 만들기는 부담스러워요. asyncio는 스레드 하나에서 수많은 작업을 번갈아 돌리는 방식이에요. 작업이 await로 "기다리는 동안 다른 일을 해도 돼"라고 스스로 차례를 넘기면, 이벤트 루프가 준비된 다른 작업을 이어서 실행해요. 웹 트랙의 비동기 강의에서 본 자바스크립트의 async/await와 같은 생각이에요.

import asyncio

async def fetch(i):                                  # await 하는 동안 다른 작업에 차례를 넘겨요
    await asyncio.sleep(0.1)
    return i

async def fetch_blocking(i):                         # 실수: 막는 호출을 그대로 쓰면
    time.sleep(0.1)
    return i

async def main(worker, n):
    start = time.perf_counter()
    results = await asyncio.gather(*(worker(i) for i in range(n)))
    return len(results), time.perf_counter() - start

count, sec = asyncio.run(main(fetch, 1_000))
print(f"요청 {count:,}개를 동시에: 0.5초 안에 끝났나요?", sec < 0.5)
count, sec = asyncio.run(main(fetch_blocking, 5))
print(f"time.sleep을 쓴 요청 {count}개: 0.45초 넘게 걸렸나요?", sec > 0.45)
요청 1,000개를 동시에: 0.5초 안에 끝났나요? True
time.sleep을 쓴 요청 5개: 0.45초 넘게 걸렸나요? True

요청 1,000개가 각각 0.1초를 기다리는데, 스레드 하나로 전부 합쳐 0.1초 남짓에 끝났어요. 그런데 async 함수 안에서 time.sleep처럼 막는 호출을 쓰면 이벤트 루프 전체가 멈춰서, 5개를 차례로 기다린 것과 똑같이 0.5초가 걸려요. 차례를 넘기는 await가 없으니 다른 작업이 끼어들 수 없거든요. asyncio에서는 기다리는 일을 모두 await할 수 있는 도구(asyncio.sleep, aiohttp 같은 비동기 HTTP 라이브러리, 비동기 데이터베이스 드라이버)로 해야 하고, 어쩔 수 없이 막는 함수를 써야 하면 asyncio.to_thread로 따로 돌려요.

asyncio에는 좋은 점이 하나 더 있어요. await를 지나는 곳에서만 차례가 바뀌니, await가 없는 구간에는 다른 작업이 끼어들지 않아서 경쟁 상태가 훨씬 적어요. 대신 오래 걸리는 계산은 그동안 모든 작업을 멈춰 세우니, 계산은 프로세스로 따로 보내요.

무엇을 고를까

일의 종류고를 방법이유
네트워크나 디스크를 기다리는 일 수십 개스레드(ThreadPoolExecutor)기다리는 동안 GIL을 놓아요
네트워크를 기다리는 일 수천 개 이상asyncio스레드 하나로 수많은 연결을 다뤄요
파이썬 코드로 하는 무거운 계산프로세스(ProcessPoolExecutor)프로세스마다 GIL이 따로 있어요
큰 숫자 계산넘파이 같은 라이브러리C로 계산하며 SIMD와 여러 코어를 써요

여러 흐름이 데이터를 함께 써야 한다면, 함께 쓰는 데이터를 최대한 줄이고 큐로 주고받게 만드는 게 안전해요. queue.Queue는 여러 스레드가 동시에 넣고 꺼내도 안전한 큐예요. 일을 만드는 쪽은 큐에 넣고 일하는 쪽은 꺼내서 처리하면, 락을 직접 다룰 일이 크게 줄어요. 선형 구조 강의에서 본 작업 큐가 바로 이 모양이에요.

실습

  1. withdraw_unsafe에서 time.sleep(0)을 지우고 여러 번 돌려 보세요. 경쟁 상태가 드러나나요? 드러나지 않는다고 안전한 걸까요?
  2. 락을 반복문 전체의 바깥에 두면 결과와 속도가 어떻게 달라지나요? 락의 범위가 넓을 때의 단점은 무엇일까요?
  3. 교착 상태 실험을 계좌 세 개, 스레드 세 개로 늘리고, "계좌 이름순으로 락을 잡는다"는 규칙으로 고쳐 보세요.
  4. count_up을 ProcessPoolExecutor로 나눠 돌리는 스크립트 파일을 만들어 보세요. 윈도에서는 if __name__ == "__main__": 안에서 실행해야 해요. 코어 수만큼 빨라지나요?
  5. fetch_blocking의 time.sleep(0.1)을 await asyncio.to_thread(time.sleep, 0.1)로 바꾸면 5개가 얼마 만에 끝나나요?

자주 하는 실수

  • 테스트에서 멀쩡하니 안전하다고 믿는다. 경쟁 상태는 드물게만 나타나요. 함께 쓰는 데이터를 고치는 곳은 처음부터 락이나 큐로 보호해요.
  • 락을 쥐고 오래 일한다. 그동안 다른 스레드가 모두 기다려요. 락 안에서는 꼭 필요한 일만 해요.
  • 락을 잡는 순서가 제각각이다. 교착 상태로 가는 지름길이에요. 순서를 정해 두고 지켜요.
  • 계산을 스레드로 나누면 빨라질 거라 기대한다. 기본 CPython에서는 GIL 때문에 그대로예요. 프로세스나 넘파이를 써요.
  • async 함수 안에서 막는 호출을 쓴다. time.sleep, requests.get, 동기 데이터베이스 호출은 이벤트 루프 전체를 멈춰요.

점검 문제

  1. 동시성과 병렬성의 차이는?
  2. 출금 실험에서 출금이 사라진 이유는?
  3. 락은 경쟁 상태를 어떻게 막나요?
  4. 교착 상태가 생기는 조건과, 가장 확실한 예방법은?
  5. GIL이 있을 때 기다리는 일은 스레드로 빨라지고 계산하는 일은 빨라지지 않는 이유는?
  6. 파이썬에서 계산을 정말 병렬로 하는 방법 두 가지는?
  7. asyncio가 스레드 하나로 수많은 작업을 처리할 수 있는 원리는?
  8. async 함수 안에서 time.sleep을 쓰면 안 되는 이유와 대안은?

정답

  1. 동시성은 여러 일을 번갈아 조금씩 진행해 함께 다루는 것이고, 병렬성은 여러 일을 정말로 같은 순간에 실행하는 거예요. 동시성은 코어 하나로도 되지만 병렬성은 코어가 여러 개 필요해요.
  2. 잔액을 읽고 쓰는 사이에 다른 스레드가 끼어들어, 두 스레드가 같은 잔액을 읽고 각자 하나 뺀 값을 쓰면서 출금 두 번이 한 번으로 줄었기 때문이에요.
  3. 락을 쥔 스레드만 임계 구역에 들어가게 해서, 한 스레드가 읽고 쓰는 동안 다른 스레드가 끼어들지 못하게 해요.
  4. 여러 스레드가 각자 락을 쥔 채 서로가 쥔 락을 기다리면 생겨요. 모든 스레드가 락을 같은 순서로 잡도록 정해 두는 게 가장 확실한 예방법이에요.
  5. 스레드는 네트워크나 디스크를 기다리는 동안 GIL을 내려놓아 다른 스레드가 일할 수 있지만, 파이썬 코드를 실행하는 동안에는 GIL 때문에 한 번에 한 스레드만 돌 수 있기 때문이에요.
  6. 프로세스를 여러 개 쓰거나(ProcessPoolExecutor, multiprocessing), 넘파이처럼 GIL을 놓고 C로 계산하는 라이브러리를 써요. GIL 없는 파이썬 판을 쓰는 방법도 있어요.
  7. 작업이 await로 기다리는 지점마다 스스로 차례를 넘기면, 이벤트 루프가 준비된 다른 작업을 이어서 실행해요. 기다리는 동안 스레드가 놀지 않으니 하나로 수많은 작업을 돌릴 수 있어요.
  8. time.sleep은 차례를 넘기지 않고 스레드 자체를 멈춰서, 이벤트 루프 위의 모든 작업이 함께 멈추기 때문이에요. await asyncio.sleep을 쓰고, 막는 함수는 asyncio.to_thread로 따로 돌려요.

다음 강의

이번 강의의 스레드들은 같은 컴퓨터의 메모리를 함께 썼어요. 그런데 서비스가 커지면 컴퓨터 여러 대가 네트워크로 협력해야 하고, 그때는 메시지가 늦거나 사라지고 컴퓨터가 통째로 멈추는 일까지 생겨요. 다음 강의에서는 이런 환경에서 데이터를 여러 곳에 복제하고, 컴퓨터들이 하나의 결정에 합의하는 분산 시스템의 기초와 CAP 정리를 다뤄요.