트랜잭션과 동시성: 데이터를 지키는 약속
여러 요청이 동시에 같은 데이터를 건드릴 때 데이터베이스가 무엇을 지켜 주고, 무엇은 내가 챙겨야 하는지 배워요. 마지막 재고 하나가 두 사람에게 팔리는 경쟁을 재현하고, 확인과 빼기를 한 문장으로 합치기, 처음부터 쓰기 잠금 잡기, 버전 번호로 충돌 알아채기라는 세 가지 해결책을 손님 10명이 동시에 몰리는 상황까지 시험해요. 트랜잭션 안에서 보이는 스냅숏, 격리 수준과 이상 현상, 교착 상태, 확정 전에 프로그램이 죽었을 때 남는 것, 트랜잭션을 짧게 유지하는 실무 규칙까지 다뤄요.
첫 강의에서 트랜잭션을 "모두 되거나, 하나도 안 되거나"로 소개했어요. 송금 도중의 오류를 되돌리는 건 혼자 일할 때의 이야기예요. 실제 서비스에서는 수많은 요청이 동시에 같은 데이터를 읽고 써요. 한정판 상품이 풀리는 순간, 같은 좌석을 여러 사람이 고르는 순간이죠. 이번 강의에서는 동시에 일할 때 생기는 문제와, 데이터베이스가 그걸 막는 방법을 직접 재현하며 배워요.
마지막 재고 하나를 두 사람이 샀다
재고가 1개 남은 한정판 키보드를 민지와 준호가 거의 동시에 샀어요. 각자의 요청은 서버에서 서로 다른 데이터베이스 연결로 처리돼요. 흔히 짜는 "재고를 확인하고, 있으면 빼고, 주문을 넣는" 코드예요.
import pathlib
import sqlite3
import tempfile
path = pathlib.Path(tempfile.mkdtemp()) / "shop.db"
setup = sqlite3.connect(path)
setup.executescript("""
CREATE TABLE products (id INTEGER PRIMARY KEY, name TEXT NOT NULL, stock INTEGER NOT NULL CHECK (stock >= 0),
version INTEGER NOT NULL DEFAULT 0);
CREATE TABLE orders (id INTEGER PRIMARY KEY, product_id INTEGER NOT NULL, buyer TEXT NOT NULL);
INSERT INTO products (id, name, stock) VALUES (1, '한정판 키보드', 1);
""")
setup.close()
def connect():
return sqlite3.connect(path, isolation_level=None, timeout=0) # 문장마다 바로 확정하는 연결
a, b = connect(), connect() # 두 사람의 요청을 처리하는 두 연결
def state():
buyers = [name for (name,) in a.execute("SELECT buyer FROM orders ORDER BY id")]
return f"주문 {buyers}, 남은 재고 {a.execute('SELECT stock FROM products WHERE id = 1').fetchone()[0]}"
stock_a = a.execute("SELECT stock FROM products WHERE id = 1").fetchone()[0] # 민지: 재고 확인 → 1
stock_b = b.execute("SELECT stock FROM products WHERE id = 1").fetchone()[0] # 준호: 재고 확인 → 1
for conn, stock, buyer in ((a, stock_a, "민지"), (b, stock_b, "준호")):
if stock > 0: # 둘 다 "재고가 있다"고 봤어요
conn.execute("UPDATE products SET stock = ? WHERE id = 1", (stock - 1,))
conn.execute("INSERT INTO orders (product_id, buyer) VALUES (1, ?)", (buyer,))
print("확인하고 쓰기:", state())
확인하고 쓰기: 주문 ['민지', '준호'], 남은 재고 0
재고는 1개였는데 주문은 2개예요. 한 사람에게는 없는 물건을 판 거예요. 두 요청이 모두 "재고 1"을 읽은 뒤에 각자 "1에서 1을 빼면 0"을 썼기 때문이에요. 이렇게 실행 순서에 따라 결과가 달라지는 버그를 경쟁 상태라고 해요. 혼자 시험할 때는 절대 안 보이고, 사람이 몰리는 바로 그 순간에만 나타나요.
CHECK (stock >= 0) 규칙도 이걸 막지 못했어요. 둘 다 0을 썼으니까요. 만약 stock = stock - 1처럼 데이터베이스 안의 값에서 빼게 했다면, 둘째 쓰기가 -1을 만들려다 규칙에 걸렸을 거예요. 규칙은 마지막 방어선으로 꼭 두되, 문제 자체는 아래 방법들로 풀어요.
해결 1: 확인과 빼기를 한 문장으로
가장 간단하고 강력한 방법은 확인과 변경을 한 문장에 담는 것이에요. "재고가 0보다 크면 1을 빼라"를 한 번에 시키고, 실제로 바뀐 행이 있는지로 성공을 판단해요.
def reset(stock):
a.execute("DELETE FROM orders")
a.execute("UPDATE products SET stock = ?, version = 0 WHERE id = 1", (stock,))
def buy(conn, buyer):
conn.execute("BEGIN IMMEDIATE") # 쓰기 잠금을 처음부터 잡아요
try:
cur = conn.execute("UPDATE products SET stock = stock - 1 WHERE id = 1 AND stock > 0")
if cur.rowcount == 0: # 확인과 빼기를 한 문장으로
conn.execute("ROLLBACK")
return "품절"
conn.execute("INSERT INTO orders (product_id, buyer) VALUES (1, ?)", (buyer,))
conn.execute("COMMIT")
return "성공"
except BaseException:
conn.execute("ROLLBACK")
raise
reset(1)
print("한 문장으로:", buy(a, "민지"), buy(b, "준호"), "|", state())
import threading
reset(3)
results = []
def customer(i):
conn = sqlite3.connect(path, isolation_level=None, timeout=10) # 잠금이 풀릴 때까지 10초 기다려요
results.append(buy(conn, f"손님{i}"))
conn.close()
threads = [threading.Thread(target=customer, args=(i,)) for i in range(10)]
for t in threads:
t.start()
for t in threads:
t.join()
print("손님 10명이 동시에, 재고 3개:", results.count("성공"), "명 성공,", results.count("품절"), "명 품절 |",
"남은 재고", a.execute("SELECT stock FROM products WHERE id = 1").fetchone()[0])
한 문장으로: 성공 품절 | 주문 ['민지'], 남은 재고 0
손님 10명이 동시에, 재고 3개: 3 명 성공, 7 명 품절 | 남은 재고 0
스레드 10개가 동시에 몰려도 정확히 3명만 성공했어요. WHERE stock > 0의 확인과 stock - 1의 변경이 한 문장이라, 둘 사이에 다른 요청이 끼어들 틈이 없어요. 재고 빼기와 주문 넣기는 하나의 트랜잭션으로 묶어서, 주문을 넣다 실패하면 재고도 되돌아가게 했어요. 이 방법은 PostgreSQL이나 MySQL에서도 그대로 통해요. 같은 행을 고치려는 두 번째 요청은 첫 번째가 끝날 때까지 기다렸다가, 바뀐 값으로 조건을 다시 따져요.
해결 2: 처음부터 잠그기
확인과 변경을 한 문장에 담기 어려운 복잡한 일이라면, 읽기 전에 잠금을 잡아서 다른 쪽을 기다리게 해요. 위 buy의 BEGIN IMMEDIATE가 SQLite에서 쓰기 잠금을 처음부터 잡는 명령이에요. 기다리지 않게(timeout=0) 만든 두 연결로 확인해 볼게요.
a.execute("BEGIN IMMEDIATE")
try:
b.execute("BEGIN IMMEDIATE")
except sqlite3.OperationalError as e:
print("준호의 연결:", e)
a.execute("COMMIT")
b.execute("BEGIN IMMEDIATE")
print("민지가 끝낸 뒤에는 준호도 시작할 수 있어요")
b.execute("COMMIT")
준호의 연결: database is locked
민지가 끝낸 뒤에는 준호도 시작할 수 있어요
민지가 잠금을 잡은 동안 준호는 시작조차 못 했어요. 실제로는 timeout을 주어 잠깐 기다리게 하고, 그래도 안 되면 다시 시도해요. 앞의 손님 10명이 모두 무사했던 것도 10초까지 기다리게 했기 때문이에요. SQLite는 데이터베이스 전체에 쓰기 잠금을 하나만 둬서, 쓰기는 한 번에 하나씩 일어나요. PostgreSQL이나 MySQL은 행 단위로 잠가요. SELECT ... FOR UPDATE로 읽으면 그 행에 잠금이 걸려, 같은 행을 고치려는 다른 트랜잭션이 기다려요. 다른 상품을 사는 사람들은 기다리지 않아도 되니 훨씬 많은 요청을 함께 처리할 수 있어요.
해결 3: 버전 번호로 충돌 알아채기
관리자 두 명이 같은 상품의 편집 화면을 열어 놓고 각자 고친다면 어떨까요? 화면을 열어 둔 몇 분 동안 잠금을 잡고 있을 수는 없어요. 이럴 땐 잠그지 않고, 저장하는 순간 누가 먼저 바꿨는지 확인해요. 행마다 버전 번호를 두고, 읽은 버전 그대로일 때만 저장하게 해요.
def load(conn):
return conn.execute("SELECT name, version FROM products WHERE id = 1").fetchone()
def save(conn, new_name, seen_version):
cur = conn.execute("UPDATE products SET name = ?, version = version + 1 WHERE id = 1 AND version = ?",
(new_name, seen_version))
return "저장했어요" if cur.rowcount == 1 else "다른 사람이 먼저 고쳤어요. 새로 불러와서 다시 고쳐 주세요"
name_a, ver_a = load(a) # 관리자 A가 편집 화면을 열고
name_b, ver_b = load(b) # 관리자 B도 같은 화면을 열었어요
print("A:", save(a, "한정판 무선 키보드", ver_a))
print("B:", save(b, "한정판 키보드 (재입고)", ver_b))
print("지금 이름:", load(a))
A: 저장했어요
B: 다른 사람이 먼저 고쳤어요. 새로 불러와서 다시 고쳐 주세요
지금 이름: ('한정판 무선 키보드', 1)
A가 저장하면서 버전이 1이 됐어요. B는 버전 0을 보고 고쳤으니 조건이 맞지 않아 아무 행도 바뀌지 않았고, 덕분에 A의 변경을 덮어쓰지 않았어요. 충돌이 드물 거라 믿고 일단 진행한다고 해서 낙관적 동시성 제어라고 불러요. 반대로 해결 2처럼 미리 잠그는 건 비관적 방식이에요. 충돌이 드문 편집 화면에는 낙관적 방식이, 충돌이 잦은 재고 빼기에는 비관적 방식이나 해결 1이 어울려요.
트랜잭션 안에서 보이는 세상: 스냅숏
트랜잭션 안에서 데이터를 두 번 읽는 사이에 다른 연결이 값을 바꾸면, 두 번째 읽기에는 무엇이 보일까요? SQLite의 WAL 방식으로 확인해 볼게요.
print("저널 방식:", a.execute("PRAGMA journal_mode=WAL").fetchone()[0])
reset(5)
a.execute("BEGIN")
first = a.execute("SELECT stock FROM products WHERE id = 1").fetchone()[0]
b.execute("UPDATE products SET stock = 2 WHERE id = 1") # 그사이 다른 연결이 바꾸고 확정했어요
second = a.execute("SELECT stock FROM products WHERE id = 1").fetchone()[0]
a.execute("COMMIT")
third = a.execute("SELECT stock FROM products WHERE id = 1").fetchone()[0]
print(f"트랜잭션 안의 첫 읽기 {first}, 다른 연결이 바꾼 뒤 {second}, 트랜잭션을 끝낸 뒤 {third}")
저널 방식: wal
트랜잭션 안의 첫 읽기 5, 다른 연결이 바꾼 뒤 5, 트랜잭션을 끝낸 뒤 2
트랜잭션 안에서는 다른 연결이 값을 2로 바꾸고 확정한 뒤에도 계속 5가 보였어요. 트랜잭션을 시작할 때의 모습을 사진처럼 붙잡아 두는 스냅숏이에요. 그래서 보고서를 만드는 동안 숫자가 중간에 바뀌어 합계가 안 맞는 일이 없어요. WAL 방식에서는 읽는 쪽이 쓰는 쪽을 막지 않고, 쓰는 쪽도 읽는 쪽을 막지 않아서 동시에 일할 수 있어요.
그런데 스냅숏에는 함정도 있어요. 맨 처음의 재고 경쟁이 바로 그거예요. 각자 자기 스냅숏에서 "재고 1"을 보고 판단했으니까요. 스냅숏은 읽기를 일관되게 해 줄 뿐, 읽은 값으로 내린 판단이 쓰는 순간에도 맞는지는 보장하지 않아요.
격리 수준과 이상 현상
동시에 실행되는 트랜잭션이 서로를 얼마나 볼 수 있는지 정하는 게 격리 수준이에요. 수준이 낮을수록 빠르지만 이상한 일이 더 많이 생겨요.
| 이상 현상 | 무슨 일인가 |
|---|---|
| 더티 리드 | 다른 쪽이 아직 확정하지 않은 값을 읽어요. 그쪽이 되돌리면 없던 값을 본 셈이에요 |
| 반복 불가능 읽기 | 같은 트랜잭션에서 같은 행을 두 번 읽었는데 값이 달라요 |
| 팬텀 | 같은 조건으로 두 번 셌는데 그사이 행이 늘거나 줄었어요 |
| 갱신 분실 | 둘이 같은 값을 읽고 각자 써서 한쪽의 변경이 사라져요 |
| 쓰기 치우침 | 둘이 각자 조건을 확인하고 서로 다른 행을 고쳐서, 합쳐 보면 규칙이 깨져요 |
| 격리 수준 | 막아 주는 것 | 기본값으로 쓰는 곳 |
|---|---|---|
| READ UNCOMMITTED | 거의 없어요 | 거의 쓰지 않아요 |
| READ COMMITTED | 더티 리드 | PostgreSQL, Oracle, SQL Server |
| REPEATABLE READ | 더티 리드, 반복 불가능 읽기(구현에 따라 더 많이) | MySQL(InnoDB) |
| SERIALIZABLE | 모두. 하나씩 차례로 실행한 것과 같은 결과 | SQLite는 쓰기를 한 번에 하나만 받아 이 수준처럼 동작해요 |
쓰기 치우침의 고전적인 예는 병원 당직이에요. "당직 의사는 최소 한 명"이라는 규칙이 있고, 당직이 두 명일 때 두 의사가 동시에 퇴근 버튼을 눌러요. 둘 다 "나 말고 한 명이 더 있네"를 확인하고 각자 자기 행만 고쳐서, 결국 당직이 0명이 돼요. 고친 행이 서로 달라서 행 잠금으로도 안 막혀요. SERIALIZABLE 수준이나, 확인하는 행들을 함께 잠그는 방법(SELECT ... FOR UPDATE)으로 막아요.
중요한 건 내가 쓰는 데이터베이스의 기본 수준을 알고, 그 수준에서 생길 수 있는 일을 코드로 막는 것이에요. PostgreSQL의 기본값인 READ COMMITTED에서는 첫 예제의 재고 경쟁이 그대로 일어나요. 해결 1, 2, 3을 써야 해요. SERIALIZABLE로 올리면 데이터베이스가 위험한 트랜잭션을 거절하니, 그때는 "다시 시도하라"는 오류를 받아 트랜잭션 전체를 처음부터 다시 실행하는 코드가 필요해요.
교착 상태
트랜잭션 A가 1번 행을 잠그고 2번 행을 기다리는데, 트랜잭션 B는 2번 행을 잠그고 1번 행을 기다리면 둘 다 영원히 기다려요. 이걸 교착 상태(데드락)라고 해요. 서로 상대에게 송금하는 두 이체가 동시에 일어나면 생길 수 있어요. 데이터베이스는 이런 고리를 찾아내서 한쪽을 강제로 실패시켜요(PostgreSQL의 "deadlock detected"). 실패한 쪽은 다시 시도하면 돼요. 미리 줄이는 방법은 이래요.
- 같은 순서로 잠가요. 이체라면 계좌 번호가 작은 쪽부터 잠그기로 정해 두면 고리가 생기지 않아요.
- 트랜잭션을 짧게 유지해서 잠금을 오래 쥐고 있지 않아요.
- 실패하면 잠깐 쉬었다가 다시 시도하는 코드를 둬요.
확정한 것은 사라지지 않아요
트랜잭션의 마지막 약속은 지속성이에요. 확정(COMMIT)이 끝났다고 답했다면 그 직후 전원이 나가도 남아 있어야 하고, 확정하지 않은 것은 흔적 없이 사라져야 해요. 프로그램을 실제로 죽여서 확인해 볼게요.
import subprocess
import sys
child = f"""
import os, sqlite3
con = sqlite3.connect(r"{path}")
con.execute("INSERT INTO orders (product_id, buyer) VALUES (1, '확정한 주문')")
con.commit()
con.execute("INSERT INTO orders (product_id, buyer) VALUES (1, '확정 전 주문')")
os._exit(1) # 확정하기 전에 프로그램이 갑자기 죽었어요
"""
done = subprocess.run([sys.executable, "-c", child])
print("자식 프로그램 종료 코드:", done.returncode)
print("남은 주문:", [r for (r,) in a.execute("SELECT buyer FROM orders WHERE buyer LIKE '확정%' ORDER BY id")])
자식 프로그램 종료 코드: 1
남은 주문: ['확정한 주문']
다른 프로그램이 주문 하나를 확정하고, 하나는 넣던 도중에 정리할 틈도 없이 죽었어요. 남은 건 확정한 주문뿐이에요. 데이터베이스는 바뀔 내용을 먼저 기록(저널, WAL)에 적고, 확정할 때 그 기록이 디스크에 실제로 닿았는지 확인한 다음에야 "확정했다"고 답해요. 다시 열 때는 확정 표시가 없는 기록을 버려요. 첫 강의에서 JSON 파일이 반쪽으로 망가졌던 것과 비교해 보세요.
실무 규칙
- 트랜잭션은 짧게. 트랜잭션 안에서 사용자의 입력을 기다리거나, 결제 회사 같은 외부 API를 부르지 않아요. 몇 초씩 잠금을 쥐면 다른 요청이 모두 줄을 서요. 결제라면 "재고 예약(짧은 트랜잭션) → 결제 요청 → 결제 확인 후 확정 또는 예약 취소(짧은 트랜잭션)"처럼 나눠요.
- 실패를 예상하고 다시 시도해요. 잠금 대기 시간 초과, 교착 상태, 직렬화 실패는 정상적인 일이에요. 트랜잭션 전체를 다시 실행하는 코드를 두고, 횟수와 간격을 제한해요.
- 다시 시도해도 안전하게. 응답을 못 받아 다시 보낸 주문이 두 번 들어가지 않도록, 요청마다 고유한 번호(멱등 키)를 받아
UNIQUE로 막아요. HTTP 강의와 비동기 강의에서 본 이야기가 여기서 완성돼요. - 규칙은 데이터베이스에.
CHECK,UNIQUE, 외래 키는 코드에 경쟁 상태가 남아 있어도 데이터가 망가지는 것을 막는 마지막 방어선이에요. - 동시성은 시험으로 확인해요. 앞의 손님 10명 예제처럼, 여러 요청을 동시에 보내는 시험을 만들어 두면 경쟁 상태를 배포 전에 잡을 수 있어요.
실습
- 첫 예제의
UPDATE products SET stock = ?를stock = stock - 1로 바꿔 다시 실행해 보세요. 준호의 요청에서 어떤 오류가 나고, 주문은 어떻게 되나요? - 손님 10명 예제의
buy를 첫 예제처럼 "읽고 확인하고 쓰는" 방식으로 바꾸고, 재고 3개에 손님 50명으로 여러 번 돌려 보세요. 주문이 3개를 넘는 경우가 있나요? 그런 경우가 바로 나오지 않아도 안전하다는 뜻이 아닌 이유는 무엇일까요? - 낙관적 동시성 예제에서, 충돌이 나면 새로 불러와 B의 변경을 다시 적용하는 함수를 만들어 보세요. 몇 번까지 다시 시도할지도 정해 보세요.
- 스냅숏 예제에서
PRAGMA journal_mode=WAL대신DELETE방식으로 바꾸면 다른 연결의UPDATE는 어떻게 되나요? - 계좌 두 개 사이에서 서로 송금하는 함수를 만들고, "계좌 번호가 작은 쪽부터 잠근다"는 규칙을 코드로 표현해 보세요.
- 주문 표에
request_id TEXT UNIQUE칸을 더하고, 같은request_id로 주문을 두 번 넣으면 어떻게 되는지 확인해 보세요.
자주 하는 실수
- 확인하고 나서 쓴다. 확인과 쓰기 사이에 다른 요청이 끼어들어요. 한 문장으로 합치거나 잠가요.
- 읽은 값으로 계산해서 덮어쓴다.
stock = 읽은값 - 1대신stock = stock - 1처럼 데이터베이스 안의 값으로 계산해요. - 트랜잭션 안에서 외부 API를 부른다. 잠금이 그만큼 길어지고, 외부 호출이 실패하면 무엇을 되돌릴지 꼬여요.
- 잠금 오류를 버그로만 여긴다. 동시에 일하는 시스템에서는 정상적인 일이에요. 다시 시도하는 코드를 둬요.
- 기본 격리 수준을 모르고 쓴다. READ COMMITTED에서 무엇이 생길 수 있는지 알아야 막을 수 있어요.
- 혼자 시험해 보고 안전하다고 믿는다. 동시성 버그는 동시에 몰릴 때만 나타나요.
- 다시 시도해도 안전한지 생각하지 않는다. 멱등 키 없이 다시 보내면 주문이 두 번 들어가요.
점검 문제
- 첫 예제에서 재고가 1개인데 주문이 2개 들어간 이유는?
UPDATE ... SET stock = stock - 1 WHERE stock > 0이 경쟁 상태를 막는 이유는?BEGIN IMMEDIATE나SELECT ... FOR UPDATE는 무엇을 하나요? 둘의 범위는 어떻게 다른가요?- 버전 번호를 쓰는 낙관적 동시성 제어는 어떻게 충돌을 알아채나요? 어떤 상황에 어울리나요?
- 트랜잭션 안의 두 읽기 사이에 다른 연결이 값을 바꿨는데도 처음 값이 보인 이유는?
- 쓰기 치우침이 행 잠금으로 막히지 않는 이유는?
- 교착 상태를 줄이는 방법 세 가지는?
- 트랜잭션 안에서 외부 결제 API를 부르면 안 되는 이유와 대안은?
정답
- 두 요청이 모두 재고 1을 읽은 뒤, 각자 읽은 값에서 1을 뺀 0을 썼기 때문이에요. 확인과 쓰기 사이에 다른 요청이 끼어든 경쟁 상태예요.
- 확인(재고가 0보다 큰가)과 변경(1 빼기)이 한 문장이라 사이에 끼어들 틈이 없기 때문이에요. 바뀐 행이 없으면 품절로 판단해요.
- 읽기 전에 쓰기 잠금을 잡아서 같은 데이터를 고치려는 다른 트랜잭션을 기다리게 해요. SQLite의
BEGIN IMMEDIATE는 데이터베이스 전체를,SELECT ... FOR UPDATE는 읽은 행만 잠가요. - 읽을 때의 버전 번호를 저장 조건(
WHERE version = ?)에 넣어서, 그사이 다른 사람이 저장해 버전이 바뀌었으면 아무 행도 바뀌지 않는 것으로 알아채요. 충돌이 드물고 편집 화면처럼 오래 열어 두는 상황에 어울려요. - 트랜잭션을 시작할 때의 모습을 스냅숏으로 붙잡아 두고, 트랜잭션이 끝날 때까지 그 모습을 보여 주기 때문이에요.
- 두 트랜잭션이 고치는 행이 서로 달라서, 행마다 거는 잠금끼리는 부딪히지 않기 때문이에요. SERIALIZABLE 수준이나, 확인한 행들까지 함께 잠가서 막아요.
- 모두 같은 순서로 잠그기, 트랜잭션을 짧게 유지하기, 실패하면 잠깐 쉬었다 다시 시도하기예요.
- 외부 호출이 오래 걸리는 동안 잠금을 쥐고 있어서 다른 요청이 모두 기다리고, 외부 호출이 실패했을 때 되돌릴 범위가 꼬이기 때문이에요. 재고 예약, 결제, 확정 또는 취소를 짧은 트랜잭션 여러 개로 나눠요.
다음 강의
데이터베이스 트랙을 마쳤어요. 이제 데이터를 잃지 않고, 빠르게 꺼내고, 동시에 몰려도 지킬 수 있어요. 다음은 서버 트랙이에요. 지금까지 따로 배운 HTTP, 데이터베이스, 파이썬을 하나로 묶어, 요청을 받아 데이터베이스를 읽고 쓰고 응답하는 백엔드 서버를 처음부터 만들어 봐요.