들어가며
이 글은 거의 동시에 들어온 요청 두 개가 같은 데이터를 두 번 만드는 문제를 다룹니다.
예제는 "최근 본 글" 기능입니다. 코드는 단순합니다. "기록이 있는지 찾아보고, 없으면 만든다." 요청이 하나씩 올 때는 아무 문제가 없습니다. 그런데 요청 두 개가 거의 같은 순간에 오면 기록이 두 개 생길 수 있습니다. DB의 잠금 기능을 써도 막히지 않는 경우가 있습니다.
이 글에서 따라갈 순서는 다음과 같습니다.
- 예제 기능과 코드를 봅니다.
- 요청 두 개가 동시에 오면 무슨 일이 생기는지 봅니다.
- 잠금으로 막아 보고, 어떤 경우에 막히지 않는지 봅니다.
- 유니크 제약으로 해결합니다.
- 같은 문제가 생기는 다른 코드를 정리합니다.
맨 뒤의 "더 알아보기"는 실제 SQL, 격리 수준 같은 심화 내용입니다. 처음 읽을 때는 건너뛰어도 됩니다.
예제 기준 버전: Django 6.1.
검증 환경: Django 6.1.3, mysqlclient 2.3.1, MariaDB 11.8 (InnoDB).
예제: "최근 본 글" 기록
사용자가 글을 열 때마다 기록을 남깁니다. 기록을 담는 표 post_view는 이렇게 생겼습니다.
| id | user_id | post_id | count |
|---|---|---|---|
| 1 | 7 | 500 | 3 |
| 2 | 9 | 500 | 1 |
첫 줄은 "사용자 7이 글 500을 3번 봤다"는 뜻입니다.
규칙은 하나입니다. 사용자와 글 한 쌍에 행은 하나만 있어야 합니다. 사용자 7이 글 500을 또 보면 새 행을 만들지 않고, 있던 행의 count만 1 올립니다.
모델은 다음과 같습니다.
class PostView(models.Model):
user = models.ForeignKey(User, on_delete=models.CASCADE)
post = models.ForeignKey(Post, on_delete=models.CASCADE)
count = models.PositiveIntegerField(default=0)
class Meta:
db_table = 'post_view'
기록하는 함수는 세 단계로 되어 있습니다.
from django.db.models import F
def record_view(user, post):
try:
view = PostView.objects.get(user=user, post=post) # 1. 찾기
except PostView.DoesNotExist:
view = PostView.objects.create(user=user, post=post) # 2. 없으면 만들기
PostView.objects.filter(pk=view.pk).update(count=F('count') + 1) # 3. count 1 올리기
F('count') + 1은 "파이썬에서 계산하지 말고, DB가 지금 값에 1을 더하라"는 뜻입니다. 왜 이렇게 쓰는지는 "더 알아보기"에서 다룹니다.
요청 두 개가 동시에 오면
먼저 "동시에"가 무슨 뜻인지 짚고 가겠습니다.
웹 서버는 보통 요청을 여러 프로세스(또는 스레드)가 나눠서 처리합니다. 사용자가 버튼을 빠르게 두 번 누르거나 앱이 같은 요청을 두 번 보내면, 두 요청이 서로 다른 프로세스에서 같은 순간에 처리될 수 있습니다. 프로세스마다 DB 연결이 따로 있습니다. 그래서 DB 입장에서는 서로를 모르는 연결 두 개가 같은 일을 동시에 하는 셈입니다.
장면 1: 사용자 7이 글 600을 처음 보는데, 요청이 두 번 왔다
| 순서 | 요청 1 | 요청 2 |
|---|---|---|
| 1 | 찾기 → 없음 | |
| 2 | 찾기 → 없음 | |
| 3 | 만들기 | |
| 4 | 만들기 |
두 요청 모두 "없음"을 봤기 때문에 둘 다 만듭니다. 표는 이렇게 됩니다.
| id | user_id | post_id | count |
|---|---|---|---|
| 3 | 7 | 600 | 1 |
| 4 | 7 | 600 | 1 |
규칙이 깨졌습니다. 문제는 여기서 끝나지 않습니다.
다음에 사용자 7이 글 600을 보면, 1단계의 get()이 행 두 개를 받습니다. get()은 결과가 정확히 하나라고 기대하므로 MultipleObjectsReturned 에러를 냅니다. 행 두 개는 그대로 남아 있으니 이 에러는 그 뒤로 볼 때마다 납니다.
이렇게 확인하고 나서 쓰는 코드에서, 확인과 쓰기 사이에 다른 요청이 끼어들어 생기는 문제를 Check-then-Act 경쟁 조건(race condition) 이라고 부릅니다.
첫 번째 시도: 잠금
DB에는 이런 상황을 막으라고 만든 기능이 있습니다. 먼저 용어 두 개를 알아야 합니다.
- 트랜잭션: 여러 SQL 문장을 하나로 묶은 단위입니다. 묶인 문장은 전부 반영되거나 전부 취소됩니다. 반영을 확정하는 것을 커밋이라고 합니다. Django에서는
with transaction.atomic():블록 하나가 트랜잭션 하나입니다. - 잠금:
select_for_update()로 읽으면 DB가 읽은 행을 잠급니다. 다른 트랜잭션이 같은 행을select_for_update()로 읽으려 하면, 앞의 트랜잭션이 커밋할 때까지 기다려야 합니다. 잠금은 커밋할 때 풀립니다.
찾기와 만들기를 트랜잭션 하나로 묶고, 찾을 때 잠그도록 고쳐 봅니다.
from django.db import transaction
def record_view(user, post):
with transaction.atomic():
try:
view = PostView.objects.select_for_update().get(user=user, post=post) # 찾으면서 잠금
except PostView.DoesNotExist:
view = PostView.objects.create(user=user, post=post)
# with 블록을 나오면서 커밋 → 잠금이 풀림
PostView.objects.filter(pk=view.pk).update(count=F('count') + 1)
의도는 이렇습니다. 요청 1이 찾는 순간 잠그고, 만들기까지 마친 뒤 커밋하면서 잠금을 풉니다. 그동안 요청 2는 기다리다가, 풀려난 뒤에는 요청 1이 만든 행을 찾습니다.
이 의도가 통하는지 알려면 "찾기"가 실제로 무엇을 읽는지 알아야 합니다.
DB는 표 전체를 읽지 않습니다. DB는 행을 빨리 찾으려고, 특정 칸의 값 순서로 행을 정리한 목록을 따로 만들어 둡니다. 이것을 색인(index) 이라고 합니다. 이 예제에는 post_id 색인과 user_id 색인이 있습니다. Django는 외래 키 칸마다 색인을 만들어 줍니다.
WHERE user_id = 7 AND post_id = 600으로 찾을 때, DB는 두 색인 중 하나를 고릅니다. 그리고 그 색인에서 해당하는 행들만 꺼내 보고, 조건에 맞는지 확인합니다. 어느 색인을 고를지는 DB가 데이터를 보고 정합니다. select_for_update()는 이렇게 꺼내 본 행을 잠급니다.
장면 2: 다른 사람이 이미 본 글 — 잠금이 막아 준다
사용자 3과 사용자 9가 이미 글 500을 봤습니다. 그래서 post_id = 500인 행이 2개 있고, DB는 post_id 색인을 골랐습니다. 이제 사용자 7의 요청 두 개가 동시에 들어옵니다.
| 순서 | 요청 1 | 요청 2 |
|---|---|---|
| 1 | 글 500의 행 2개를 꺼내 봄 → 잠금 → 사용자 7의 행은 없음 | |
| 2 | 같은 행 2개를 꺼내려다 잠겨 있어서 기다림 | |
| 3 | 만들기 → 커밋 → 잠금 풂 → count 1 |
|
| 4 | 다시 꺼내 봄 → 요청 1이 만든 행을 찾음 → 만들지 않음 | |
| 5 | count 2 |
결과는 행 1개, count = 2입니다. 의도대로 처리됐습니다.
실험에서도 확인했습니다. 요청 1을 찾기 직후 2초 동안 멈추게 하고, 요청 2를 0.2초 늦게 출발시켰습니다. 요청 2는 약 1.8초 동안 기다렸다가, 요청 1이 커밋한 직후에 풀려났습니다. 잠금은 찾기가 끝났을 때가 아니라 커밋할 때까지 유지된다는 뜻입니다.
장면 3: 아무도 안 본 글 — 잠금이 막지 못한다
이번에는 아무도 본 적 없는 글 600입니다. post_id = 600인 행이 하나도 없습니다.
| 순서 | 요청 1 | 요청 2 | 걸려 있는 잠금 |
|---|---|---|---|
| 1 | 꺼내 볼 행 0개 → 없음 | 없음 | |
| 2 | 꺼내 볼 행 0개 → 없음 | 없음 | |
| 3 | 만들기 → 커밋 | ||
| 4 | 만들기 → 커밋 |
장면 1과 똑같이 행이 두 개 생깁니다.
요청 1이 잠금을 일찍 풀어서 생긴 일이 아닙니다. 꺼내 본 행이 0개였으니 처음부터 잠글 행이 없었습니다. 이 글의 핵심은 이 한 문장입니다.
아직 없는 행은 잠글 수 없습니다.
"찾아보고 없으면 만들기"를 잠금으로 지키려고 하면, 바로 지켜야 할 순간인 "없을 때"에 걸 잠금이 없습니다.
꺼내 볼 행이 0개가 되는 때는 두 가지입니다.
- DB가
post_id색인을 골랐는데, 그 글을 아무도 본 적이 없을 때 - DB가
user_id색인을 골랐는데, 그 사용자가 아무 글도 본 적이 없을 때
실제로 많이 본 글과 기록이 없는 사용자의 조합에서는 DB가 user_id 색인을 골랐습니다(EXPLAIN으로 확인). 어느 색인을 고를지는 데이터에 따라 달라지므로, 코드만 보고는 언제 뚫리는지 알 수 없습니다. 장면 2에서 막힌 것도 누가 그렇게 설계해서가 아닙니다. 다른 사람의 행이 마침 있었기 때문입니다.
실험으로 확인한 것
잠금을 건 코드를 두 프로세스에서 동시에 실행해 보았습니다.
| 해 본 것 | 결과 |
|---|---|
| 특별한 조작 없이 두 요청을 동시에 출발시키기, 20번 | 중복 0번 |
| 아무도 안 본 글에서, 두 요청이 찾기를 마친 순간에 맞춰 함께 만들게 함 | 행 2개 |
| 다른 사람이 본 글에서, 요청 1을 찾기 직후 2초 멈춤 | 요청 2가 약 1.8초 기다린 뒤 요청 1의 행을 찾음 (행 1개, count = 2) |
| 잠금만 걸어 보기 (DB 연결 두 개, 끝에 모두 취소) | 꺼낼 행이 있으면 두 번째 연결이 기다림, 0개면 바로 통과 |
첫 줄이 0번인 이유는 찾기와 만들기 사이의 틈이 1ms(0.001초) 안팎이기 때문입니다. 두 요청이 그 짧은 틈 안에서 겹쳐야만 중복이 생깁니다. 그래서 드물지만 막혀 있지는 않은 상태입니다. 타이밍을 맞추는 방법은 "더 알아보기"에 적었습니다.
해결: 유니크 제약
유니크 제약은 DB에 "같은 (user, post) 행은 하나만"이라는 규칙을 직접 걸어 두는 것입니다.
class PostView(models.Model):
...
class Meta:
db_table = 'post_view'
constraints = [
models.UniqueConstraint(fields=['user', 'post'], name='uniq_post_view_user_post'),
]
잠금과 다른 점은 검사하는 때입니다. 잠금은 찾기 단계에서 동작하지만, 유니크 제약은 행을 넣는 순간에 DB가 직접 검사합니다. 같은 쌍이 이미 있으면 넣기를 거부하고, Django에서는 IntegrityError가 납니다. 그래서 찾을 때 행이 0개였어도 막을 수 있습니다.
| 순서 | 요청 1 | 요청 2 |
|---|---|---|
| 1 | 찾기 → 없음 | 찾기 → 없음 |
| 2 | 만들기 → 성공 | 만들기 → 거부 (IntegrityError) |
| 3 | 거부당하면 count 1 올리기로 넘어감 |
요청 1이 아직 커밋하기 전이라면, 요청 2의 넣기는 요청 1의 커밋을 기다렸다가 거부됩니다.
방법 1: 먼저 올려 보고, 없으면 만들기
from django.db import IntegrityError, transaction
from django.db.models import F
def record_view(user, post):
views = PostView.objects.filter(user=user, post=post)
if views.update(count=F('count') + 1): # 바뀐 행 수: 1이면 이미 있던 행
return
try:
with transaction.atomic():
PostView.objects.create(user=user, post=post, count=1)
except IntegrityError:
# 그 사이 다른 요청이 먼저 만들었다
views.update(count=F('count') + 1)
경우마다 이렇게 처리됩니다.
- 이미 본 글:
update()한 번으로 끝납니다.update()는 바꾼 행의 수를 돌려주는데, 1이면 이미 있던 행을 올린 것입니다. - 처음 보는 글:
update()가 0을 돌려주므로,count = 1로 새 행을 만듭니다. - 처음 보는 글에 요청이 동시에 두 번: 하나만 만들기에 성공합니다. 나머지는
IntegrityError를 받아count를 올리는 쪽으로 돌아갑니다.
create()를 transaction.atomic()으로 감싼 이유가 있습니다. 이 함수가 더 큰 트랜잭션 안에서 불릴 수도 있는데, 그 안에서 IntegrityError가 나면 바깥 트랜잭션 전체를 더 쓸 수 없게 됩니다. 안쪽 atomic()은 실패한 넣기만 되돌려서 바깥 트랜잭션을 지킵니다.
방법 2: Django의 get_or_create에 맡기기
Django의 get_or_create()는 잠금을 쓰지 않습니다. 순서는 이렇습니다.
get()을 시도합니다.- 없으면
create()를 시도합니다. IntegrityError가 나면 다시get()을 합니다.
즉 처음부터 유니크 제약에 기대는 구조입니다. 공식 문서에도 이렇게 적혀 있습니다.
This method is atomic assuming that the database enforces uniqueness of the keyword arguments (see
uniqueorunique_together).
"DB가 유니크를 강제한다는 전제에서 원자적"이라는 뜻입니다. 유니크 제약이 없으면 동시 호출에서 같은 값의 행이 여러 개 들어갈 수 있다는 경고가 바로 이어집니다. 제약을 걸었다면 아래 코드도 안전합니다.
view, _ = PostView.objects.get_or_create(user=user, post=post)
PostView.objects.filter(pk=view.pk).update(count=F('count') + 1)
방법 1보다 SQL이 하나 더 나가지만 읽기 쉽습니다.
유니크 제약을 걸기 전에 확인할 것
- 이미 들어가 있는 중복 행: 중복이 남아 있으면 제약을 추가하는 단계가 실패합니다. 먼저 정리해야 합니다.
- 비어 있을(NULL) 수 있는 칸: MySQL과 MariaDB의 유니크 제약은 NULL끼리는 같은 값으로 치지 않습니다. 예를 들어
post와comment중 하나만 채우는 표에(user, post, comment)제약 하나를 걸면,comment가 NULL인 행끼리는 중복이 막히지 않습니다. 이럴 때는(user, post)와(user, comment)로 나눠서 겁니다.
같은 문제가 생기는 다른 코드
지금까지 본 것은 "행이 없으면 만든다"였습니다. 같은 원리가 확인하고 나서 쓰는 코드 전체에 적용됩니다. 기준은 하나입니다.
"없음"이나 "개수"를 확인하고 쓰면 잠금으로 못 막고, 이미 있는 행의 값을 확인하고 쓰면 잠금으로 막을 수 있습니다.
| 코드 | 무엇을 확인하나 | 동시 요청에서 |
|---|---|---|
get_or_create() |
행이 없음 | 뚫림 (이 글의 예제) |
update_or_create() |
행이 없음 | 뚫림. 내부가 select_for_update().get_or_create()입니다 |
if not qs.exists(): qs.create(...) |
행이 없음 | 뚫림 |
폼·모델의 유니크 검증 (validate_unique()) |
같은 값의 행이 없음 | 뚫림. 내부가 exists()로 찾아보는 SELECT입니다 |
if qs.count() < 100: create(...) |
행의 개수 | 뚫림. 새로 들어올 행은 잠글 수 없습니다 |
상품 행을 select_for_update()로 읽고, 재고가 남았으면 1 빼기 |
이미 있는 행의 값 | 막힘. 잠글 행이 이미 있습니다 |
마지막 줄과 비교하면 원리가 보입니다. select_for_update()가 쓸모없는 것이 아닙니다. 잠글 행이 이미 있을 때만 쓸모가 있습니다.
폼이나 모델의 유니크 검증은 사용자에게 알아보기 쉬운 에러 메시지를 주려는 것입니다. 동시 요청을 실제로 막는 것은 DB의 유니크 제약입니다. unique=True나 UniqueConstraint 없이 clean()에서 exists()로만 검사하면 중복이 들어갈 수 있습니다.
확인하는 것에 따라 해결이 다릅니다
중복 금지("같은 값이 없으면 넣기")는 앞에서 본 유니크 제약으로 풉니다.
개수 제한("100명이 안 됐으면 넣기")은 유니크 제약으로 표현할 수 없습니다. 방법은 두 가지입니다.
첫째, 이미 있는 행을 대신 잠급니다. 선착순 이벤트라면 이벤트 행을 select_for_update()로 잠근 뒤 참가자 수를 셉니다. 같은 이벤트에 대한 요청은 모두 이 행에서 차례를 기다리게 됩니다.
with transaction.atomic():
event = Event.objects.select_for_update().get(pk=event_id)
if event.entries.count() < event.capacity:
Entry.objects.create(event=event, user=user)
둘째, 남은 자리 수를 칸 하나에 두고, 조건을 붙인 UPDATE 한 문장으로 줄입니다.
with transaction.atomic():
taken = Event.objects.filter(pk=event_id, seats__gt=0).update(seats=F('seats') - 1)
if taken: # 1이면 자리를 얻음, 0이면 마감
Entry.objects.create(event_id=event_id, user=user)
"남았는지 확인"과 "줄이기"가 UPDATE 한 문장 안에서 함께 일어나므로 끼어들 틈이 없습니다. atomic()으로 묶은 이유는, 참가 행을 넣다가 실패하면 줄인 자리도 함께 되돌리기 위해서입니다.
이 글에서 실험으로 확인한 것은 "찾아보고 없으면 만들기" 꼴입니다.
update_or_create()와 유니크 검증은 Django 소스로 구조를 확인했습니다. 개수 제한의 두 방법은 같은 원리로 정리한 것이고 실험하지는 않았습니다.
더 알아보기
여기부터는 심화 내용입니다.
실제로 나가는 SQL
잠금을 건 코드에서 사용자 7이 글 600을 처음 볼 때, DB로 나가는 SQL은 다음과 같습니다. 칸 목록은 ...으로 줄였습니다.
-- transaction.atomic() 진입: autocommit 끄기
SELECT ... FROM post_view WHERE (post_id = 600 AND user_id = 7) LIMIT 21 FOR UPDATE;
INSERT INTO post_view (user_id, post_id, count) VALUES (7, 600, 0) RETURNING id;
-- atomic() 종료: COMMIT, autocommit 다시 켜기
UPDATE post_view SET count = (count + 1) WHERE id = 3;
- 트랜잭션은
BEGIN으로 시작하지 않습니다. MySQL 계열에서 Django는 DB 드라이버의autocommit(False)를 호출합니다. autocommit은 문장마다 바로 커밋하는 설정입니다. 이것이 꺼진 뒤의 문장부터COMMIT까지가 하나의 트랜잭션이 됩니다. 서버 통계(SHOW SESSION STATUS LIKE 'Com_%')로 보면, 이 구간에BEGIN은 0번이고SET이 2번(끄기와 켜기),COMMIT이 1번 들어옵니다. LIMIT 21:get()은 결과가 정확히 하나인지 확인하려고 최대 21개까지 가져옵니다. 2개 이상이 오면MultipleObjectsReturned를 냅니다.- UPDATE는 트랜잭션 밖에서 나갑니다. autocommit 상태의 문장은 실행되자마자 확정되므로
COMMIT이 따로 오지 않습니다.
count + 1을 F()로 쓰는 이유
F('count') + 1은 SQL에서 count = (count + 1)이 됩니다. DB가 그 순간의 값을 읽어 1을 더합니다. UPDATE는 행을 잠그므로 두 요청이 동시에 와도 차례로 처리됩니다.
현재 count = 5
요청 1: count + 1 → 6으로 바꿈, 커밋
요청 2: (요청 1이 끝날 때까지 기다림) → 6을 읽어 7
결과: 7파이썬에서 계산하면(view.count += 1 후 view.save()) SQL은 count = 6처럼 계산된 값이 됩니다.
요청 1: 5를 읽음 요청 2: 5를 읽음
요청 1: count = 6 저장 요청 2: count = 6 저장
결과: 6 -- 1이 사라짐이것을 갱신 손실(lost update) 이라고 합니다.
격리 수준과 갭 락
격리 수준은 동시에 도는 트랜잭션끼리 서로의 변경을 얼마나 보고, 어떻게 잠그는지 정하는 설정입니다. MySQL과 MariaDB 서버의 기본값은 REPEATABLE READ입니다. 그런데 Django의 MySQL 백엔드는 접속할 때 자기 연결만 READ COMMITTED로 바꿉니다.
SELECT @@session.transaction_isolation, @@global.transaction_isolation;
-- Django 연결에서: READ-COMMITTED, REPEATABLE-READ
그래서 mysql 클라이언트로 직접 붙어서 실험하면 애플리케이션과 조건이 달라집니다. 같은 조건으로 실험하려면 먼저 SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED;를 실행합니다.
REPEATABLE READ에는 갭 락(gap lock) 이 있습니다. 색인의 빈 구간을 잠가서 다른 트랜잭션이 그 사이에 행을 넣지 못하게 하는 잠금입니다. 아직 없던 행이 다른 트랜잭션에서 끼어드는 현상을 팬텀(phantom) 이라고 부르는데, 갭 락은 이것을 막으려고 있습니다.
그럼 격리 수준을 바꾸면 해결될까요? 아닙니다. 갭 락끼리는 서로 충돌하지 않아서 두 요청이 같은 빈 구간을 동시에 잠글 수 있습니다. 실험에서는 이렇게 진행됐습니다.
- 두 요청 모두 기다림 없이 찾기를 통과했습니다.
- 두 넣기가 상대의 갭 락에 막혀 서로를 기다렸습니다. 이런 상태를 deadlock이라고 합니다.
- DB가 한쪽에
1213 Deadlock found에러를 내고, 그 트랜잭션 전체를 취소했습니다.
중복은 막히지만 한 요청은 에러로 끝나므로, 재시도를 따로 짜야 합니다.
주의할 점이 있습니다. deadlock이 나면 실패한 문장만 다시 실행하는 재시도 코드를 두는 경우가 있습니다. 그런데 deadlock이 나면 DB는 문장 하나가 아니라 트랜잭션 전체를 취소합니다. 그 상태에서 넣기 한 문장만 다시 실행하면, 앞의 찾기와 잠금은 사라진 채 넣기만 성공합니다. 그런 재시도 코드가 있는 환경에서 실험했을 때 실제로 행이 2개가 됐습니다.
실험 방법과 팁
그냥 동시에 출발시키면 1ms 안팎의 틈을 맞추기 어렵습니다. 그래서 Django가 SQL을 실행하는 함수에 "찾기를 마친 직후, 상대 프로세스도 찾기를 마칠 때까지 기다리기"를 끼워 넣었습니다.
from django.db.backends.utils import CursorWrapper
def install_pause(barrier): # barrier = multiprocessing.Barrier(2), 두 프로세스가 공유
original = CursorWrapper._execute
def paused(self, sql, params, *args):
result = original(self, sql, params, *args)
if 'FOR UPDATE' in sql and 'post_view' in sql:
barrier.wait(timeout=10) # 두 프로세스가 모두 찾기를 마칠 때까지 대기
return result
CursorWrapper._execute = paused
실험 팁: 트랜잭션 안에서 일부러 멈추는 실험은 서버의
wait_timeout(놀고 있는 연결을 끊는 시간)에 걸릴 수 있습니다. 연결이 끊기면 그 트랜잭션은 취소되고 잠금도 풀립니다. 처음 실험에서는 이 때문에 장면 2에서도 중복이 "재현된 것처럼" 보였습니다. 멈추게 할 연결에는SET SESSION wait_timeout = 60처럼 넉넉한 값을 먼저 걸어 둡니다.
정리
- 확인하고 나서 쓰는 코드(Check-then-Act)는, 동시에 온 두 요청이 모두 확인을 통과해 둘 다 쓸 수 있습니다.
select_for_update()는 꺼내 본 행만 잠그고, 그 잠금은 커밋할 때까지 유지됩니다.- 아직 없는 행은 잠글 수 없습니다. 그래서 꺼내 볼 행이 0개일 때 잠금이 아무것도 막지 못합니다. 다른 행이 있어서 막히는 것은 우연입니다.
- 기준: "없음"이나 "개수"를 확인하고 쓰면 잠금으로 못 막고, 이미 있는 행의 값을 확인하고 쓰면 막을 수 있습니다.
- 중복 금지는 유니크 제약으로 풉니다. DB가 넣는 순간에 검사하므로 행이 없을 때도 막습니다. Django의
get_or_create()도 이 제약을 전제로 안전합니다. - 개수 제한은 이미 있는 행을 대신 잠그거나, 조건을 붙인 UPDATE 한 문장으로 풉니다.
'Django' 카테고리의 다른 글
| [Django] Pagination (0) | 2026.11.05 |
|---|---|
| [Django] 모델 필드의 null=True와 blank=True 조건 (0) | 2025.04.05 |
| [Django] select_related와 prefetch_related 비교 (0) | 2025.02.21 |
| [Django] Django Debug Toolbar의 윈도우 환경 MIME type 오동작 해결 (0) | 2025.02.20 |
| [Django] CreateView (0) | 2025.02.04 |
