Python 스레딩 프리미티브 마스터하기: Lock, RLock, Semaphore 및 Condition Variables

동시성 프로그래밍 영역에서 Python은 여러 스레드를 관리하고 데이터 무결성을 보장하는 강력한 도구를 제공합니다. Lock, RLock, Semaphore, Condition Variables와 같은 스레딩 프리미티브를 이해하고 활용하는 것은 강력하고 효율적인 멀티스레드 애플리케이션을 구축하는 데 중요합니다. 이 종합 가이드는 각 프리미티브를 자세히 살펴보고, Python에서 동시성을 마스터하는 데 도움이 되는 실제적인 예시와 통찰력을 제공합니다.

스레딩 프리미티브가 중요한 이유

멀티스레딩을 통해 프로그램의 여러 부분을 동시에 실행할 수 있으며, 특히 I/O 바운드 작업에서 성능을 향상시킬 수 있습니다. 그러나 공유 리소스에 대한 동시 접근은 경쟁 조건, 데이터 손상 및 기타 동시성 관련 문제로 이어질 수 있습니다. 스레딩 프리미티브는 스레드 실행을 동기화하고, 충돌을 방지하며, 스레드 안전을 보장하는 메커니즘을 제공합니다.

여러 스레드가 공유 은행 계좌 잔액을 동시에 업데이트하려고 시도하는 시나리오를 생각해 보십시오. 적절한 동기화가 없으면 한 스레드가 다른 스레드가 변경한 내용을 덮어쓸 수 있어 잘못된 최종 잔액이 발생할 수 있습니다. 스레딩 프리미티브는 교통 통제관 역할을 하여 한 번에 하나의 스레드만 코드의 임계 영역에 접근하도록 보장하여 이러한 문제를 방지합니다.

전역 인터프리터 잠금 (GIL)

프리미티브에 대해 자세히 알아보기 전에 Python의 전역 인터프리터 잠금(GIL)을 이해하는 것이 중요합니다. GIL은 한 번에 하나의 스레드만 Python 인터프리터의 제어권을 가질 수 있도록 하는 뮤텍스입니다. 이는 다중 코어 프로세서에서도 Python 바이트코드의 진정한 병렬 실행이 제한됨을 의미합니다. GIL이 CPU 바운드 작업에 병목 현상이 될 수 있지만, 스레드가 대부분의 시간을 외부 리소스를 기다리는 데 사용하는 I/O 바운드 작업에는 스레딩이 여전히 유용할 수 있습니다. 또한 NumPy와 같은 라이브러리는 계산 집약적인 작업을 위해 GIL을 해제하여 진정한 병렬 처리를 가능하게 합니다.

1. Lock 프리미티브

Lock이란?

Lock(뮤텍스라고도 함)은 가장 기본적인 동기화 프리미티브입니다. 한 번에 하나의 스레드만 Lock을 획득할 수 있도록 합니다. Lock을 획득하려는 다른 스레드는 Lock이 해제될 때까지 블록(대기)됩니다. 이는 공유 리소스에 대한 독점적인 접근을 보장합니다.

Lock 메서드

• acquire([blocking]): Lock을 획득합니다. If blocking이 True(기본값)이면 Lock을 사용할 수 있을 때까지 스레드가 블록됩니다. If blocking이 False이면 메서드는 즉시 반환됩니다. Lock이 획득되면 True를 반환하고, 그렇지 않으면 False를 반환합니다.
• release(): Lock을 해제하여 다른 스레드가 획득할 수 있도록 합니다. 잠금 해제된 Lock에 대해 release()를 호출하면 RuntimeError가 발생합니다.
• locked(): Lock이 현재 획득되었으면 True를 반환하고, 그렇지 않으면 False를 반환합니다.

예시: 공유 카운터 보호

여러 스레드가 공유 카운터를 증가시키는 시나리오를 생각해 보십시오. Lock이 없으면 경쟁 조건으로 인해 최종 카운터 값이 잘못될 수 있습니다.

            
import threading

counter = 0
lock = threading.Lock()

def increment():
 global counter
 for _ in range(100000):
 with lock:
 counter += 1

threads = []
for _ in range(5):
 t = threading.Thread(target=increment)
 threads.append(t)
 t.start()

for t in threads:
 t.join()

print(f"Final counter value: {counter}")

            

              
                Copy
              
            
          

이 예시에서 with lock: 문은 한 번에 하나의 스레드만 counter 변수에 접근하고 수정할 수 있도록 보장합니다. with 문은 예외가 발생하더라도 블록 시작 시 Lock을 자동으로 획득하고 끝날 때 해제합니다. 이 구조는 lock.acquire() 및 lock.release()를 수동으로 호출하는 것보다 더 깔끔하고 안전한 대안을 제공합니다.

실생활 비유

한 번에 한 대의 차량만 통행할 수 있는 단일 차선 다리를 상상해 보십시오. Lock은 다리에 대한 접근을 통제하는 문지기와 같습니다. 차량(스레드)이 건너고 싶으면 문지기의 허락을 받아야 합니다(Lock 획득). 한 번에 한 대의 차량만 허락을 받을 수 있습니다. 차량이 건너고 나면(임계 영역 완료), 허락을 해제하여(Lock 해제) 다른 차량이 건너갈 수 있도록 합니다.

2. RLock 프리미티브

RLock이란?

RLock(재진입 Lock)은 동일한 스레드가 블록되지 않고 Lock을 여러 번 획득할 수 있도록 하는 더 고급 유형의 Lock입니다. 이는 Lock을 보유한 함수가 동일한 Lock을 획득해야 하는 다른 함수를 호출하는 상황에서 유용합니다. 일반 Lock은 이러한 상황에서 교착 상태를 유발할 수 있습니다.

RLock 메서드

RLock의 메서드는 Lock과 동일합니다: acquire([blocking]), release(), locked(). 그러나 동작은 다릅니다. 내부적으로 RLock은 동일한 스레드에 의해 획득된 횟수를 추적하는 카운터를 유지합니다. Lock은 획득된 횟수만큼 release() 메서드가 호출될 때만 완전히 해제됩니다.

예시: RLock을 사용한 재귀 함수

공유 리소스에 접근해야 하는 재귀 함수를 생각해 보십시오. RLock이 없으면 함수는 재귀적으로 Lock을 획득하려고 할 때 교착 상태에 빠질 것입니다.

            
import threading

lock = threading.RLock()


def recursive_function(n):
 with lock:
 if n <= 0:
 return
 print(f"Thread {threading.current_thread().name}: Processing {n}")
 recursive_function(n - 1)


thread = threading.Thread(target=recursive_function, args=(5,))
thread.start()
thread.join()

            

              
                Copy
              
            
          

이 예시에서 RLock은 recursive_function이 블록되지 않고 Lock을 여러 번 획득할 수 있도록 합니다. recursive_function에 대한 각 호출은 Lock을 획득하고, 각 반환은 Lock을 해제합니다. Lock은 recursive_function에 대한 초기 호출이 반환될 때만 완전히 해제됩니다.

실생활 비유

회사의 기밀 파일에 접근해야 하는 관리자를 상상해 보십시오. RLock은 관리자가 매번 재인증할 필요 없이 파일룸의 다른 섹션에 여러 번 들어갈 수 있도록 하는 특별한 접근 카드와 같습니다. 관리자는 파일을 완전히 사용하고 파일룸을 떠난 후에만 카드를 반환해야 합니다.

3. Semaphore 프리미티브

Semaphore란?

Semaphore는 Lock보다 더 일반적인 동기화 프리미티브입니다. 이는 사용 가능한 리소스 수를 나타내는 카운터를 관리합니다. 스레드는 카운터를 감소시켜(양수일 경우) 세마포어를 획득하거나, 카운터가 양수가 될 때까지 블록될 수 있습니다. 스레드는 카운터를 증가시켜 세마포어를 해제하며, 이는 블록된 스레드를 깨울 수 있습니다.

Semaphore 메서드

• acquire([blocking]): 세마포어를 획득합니다. If blocking이 True(기본값)이면 세마포어 카운트가 0보다 커질 때까지 스레드가 블록됩니다. If blocking이 False이면 메서드는 즉시 반환됩니다. 세마포어가 획득되면 True를 반환하고, 그렇지 않으면 False를 반환합니다. 내부 카운터를 1 감소시킵니다.
• release(): 세마포어를 해제하고 내부 카운터를 1 증가시킵니다. 다른 스레드가 세마포어가 사용 가능해지기를 기다리고 있다면 그중 하나가 깨어납니다.
• get_value(): 내부 카운터의 현재 값을 반환합니다.

예시: 리소스에 대한 동시 접근 제한

데이터베이스에 대한 동시 연결 수를 제한하려는 시나리오를 생각해 보십시오. 세마포어를 사용하여 특정 시점에 데이터베이스에 접근할 수 있는 스레드 수를 제어할 수 있습니다.

            
import threading
import time
import random

semaphore = threading.Semaphore(3)  # Allow only 3 concurrent connections


def database_access():
 with semaphore:
 print(f"Thread {threading.current_thread().name}: Accessing database...")
 time.sleep(random.randint(1, 3))  # Simulate database access
 print(f"Thread {threading.current_thread().name}: Releasing database...")


threads = []
for i in range(5):
 t = threading.Thread(target=database_access, name=f"Thread-{i}")
 threads.append(t)
 t.start()

for t in threads:
 t.join()

            

              
                Copy
              
            
          

이 예시에서 세마포어는 3으로 초기화되어, 한 번에 3개의 스레드만 세마포어를 획득(데이터베이스에 접근)할 수 있음을 의미합니다. 다른 스레드는 세마포어가 해제될 때까지 블록됩니다. 이는 데이터베이스 과부하를 방지하고 동시 요청을 효율적으로 처리할 수 있도록 보장합니다.

실생활 비유

테이블 수가 제한된 인기 있는 레스토랑을 상상해 보십시오. 세마포어는 레스토랑의 좌석 수용 능력과 같습니다. 한 무리의 사람들(스레드)이 도착하면, 충분한 테이블이 있다면 즉시 앉을 수 있습니다(세마포어 카운트가 양수). 모든 테이블이 차지되어 있다면, 테이블이 비워질 때까지 대기 구역에서 기다려야 합니다(블록). 한 그룹이 떠나면(세마포어 해제), 다른 그룹이 앉을 수 있습니다.

4. Condition Variable 프리미티브

Condition Variable이란?

Condition Variable은 스레드가 특정 조건이 참이 될 때까지 기다릴 수 있도록 하는 더 고급 동기화 프리미티브입니다. 이는 항상 Lock(Lock 또는 RLock)과 연관됩니다. 스레드는 Condition Variable에서 대기할 수 있으며, 연관된 Lock을 해제하고 다른 스레드가 조건을 알릴 때까지 실행을 일시 중단합니다. 이는 생산자-소비자 시나리오 또는 스레드가 특정 이벤트에 따라 조정해야 하는 상황에서 중요합니다.

Condition Variable 메서드

• acquire([blocking]): 내부 Lock을 획득합니다. 연관된 Lock의 acquire 메서드와 동일합니다.
• release(): 내부 Lock을 해제합니다. 연관된 Lock의 release 메서드와 동일합니다.
• wait([timeout]): 내부 Lock을 해제하고 notify() 또는 notify_all() 호출에 의해 깨어날 때까지 대기합니다. Lock은 wait()가 반환되기 전에 다시 획득됩니다. 선택적 timeout 인수는 최대 대기 시간을 지정합니다.
• notify(n=1): 최대 n개의 대기 중인 스레드를 깨웁니다.
• notify_all(): 모든 대기 중인 스레드를 깨웁니다.

예시: 생산자-소비자 문제

고전적인 생산자-소비자 문제는 데이터를 생성하는 하나 이상의 생산자와 데이터를 처리하는 하나 이상의 소비자를 포함합니다. 공유 버퍼는 데이터를 저장하는 데 사용되며, 생산자와 소비자는 경쟁 조건을 피하기 위해 버퍼에 대한 접근을 동기화해야 합니다.

            
import threading
import time
import random


buffer = []
buffer_size = 5
condition = threading.Condition()


def producer():
 global buffer
 while True:
 with condition:
 if len(buffer) == buffer_size:
 print("Buffer is full, producer waiting...")
 condition.wait()

 item = random.randint(1, 100)
 buffer.append(item)
 print(f"Produced: {item}, Buffer: {buffer}")
 condition.notify()
 time.sleep(random.random())


def consumer():
 global buffer
 while True:
 with condition:
 if not buffer:
 print("Buffer is empty, consumer waiting...")
 condition.wait()

 item = buffer.pop(0)
 print(f"Consumed: {item}, Buffer: {buffer}")
 condition.notify()
 time.sleep(random.random())


producer_thread = threading.Thread(target=producer)
consumer_thread = threading.Thread(target=consumer)

producer_thread.start()
consumer_thread.start()

producer_thread.join()
consumer_thread.join()

            

              
                Copy
              
            
          

이 예시에서 condition 변수는 생산자와 소비자 스레드를 동기화하는 데 사용됩니다. 버퍼가 가득 차면 생산자는 대기하고, 버퍼가 비어 있으면 소비자는 대기합니다. 생산자가 버퍼에 항목을 추가하면 소비자를 알리고, 소비자가 버퍼에서 항목을 제거하면 생산자를 알립니다. with condition: 문은 Condition Variable과 연관된 Lock이 올바르게 획득되고 해제되도록 보장합니다.

실생활 비유

생산자(공급업체)가 물품을 배송하고 소비자(고객)가 물품을 픽업하는 창고를 상상해 보십시오. 공유 버퍼는 창고의 재고와 같습니다. Condition Variable은 공급업체와 고객이 활동을 조정할 수 있도록 하는 통신 시스템과 같습니다. 창고가 가득 차면 공급업체는 공간이 생길 때까지 기다립니다. 창고가 비어 있으면 고객은 물품이 도착할 때까지 기다립니다. 물품이 배송되면 공급업체는 고객에게 알립니다. 물품이 픽업되면 고객은 공급업체에 알립니다.

올바른 프리미티브 선택

효과적인 동시성 관리를 위해서는 적절한 스레딩 프리미티브를 선택하는 것이 중요합니다. 다음은 선택에 도움이 되는 요약입니다:

• Lock: 공유 리소스에 대한 독점적인 접근이 필요하고 한 번에 하나의 스레드만 접근해야 할 때 사용합니다.
• RLock: 재귀 함수 또는 중첩된 임계 영역과 같이 동일한 스레드가 Lock을 여러 번 획득해야 할 수 있는 경우에 사용합니다.
• Semaphore: 데이터베이스 연결 수 또는 특정 작업을 수행하는 스레드 수 제한과 같이 리소스에 대한 동시 접근 수를 제한해야 할 때 사용합니다.
• Condition Variable: 생산자-소비자 시나리오 또는 스레드가 특정 이벤트에 따라 조정해야 할 때와 같이 스레드가 특정 조건이 참이 될 때까지 기다려야 할 때 사용합니다.

일반적인 함정과 모범 사례

스레딩 프리미티브를 사용하는 것은 어려울 수 있으며, 일반적인 함정과 모범 사례를 아는 것이 중요합니다:

• 교착 상태 (Deadlock): 두 개 이상의 스레드가 서로 리소스를 해제하기를 기다리며 무기한으로 블록될 때 발생합니다. 일관된 순서로 Lock을 획득하고 Lock 획득 시 타임아웃을 사용하여 교착 상태를 방지하십시오.
• 경쟁 조건 (Race Conditions): 프로그램의 결과가 스레드가 실행되는 예측 불가능한 순서에 따라 달라질 때 발생합니다. 공유 리소스를 보호하기 위해 적절한 동기화 프리미티브를 사용하여 경쟁 조건을 방지하십시오.
• 기아 상태 (Starvation): 리소스가 사용 가능함에도 불구하고 스레드가 리소스에 대한 접근을 반복적으로 거부당할 때 발생합니다. 적절한 스케줄링 정책을 사용하고 우선순위 역전을 피하여 공정성을 보장하십시오.
• 과도한 동기화 (Over-Synchronization): 너무 많은 동기화 프리미티브를 사용하면 성능이 저하되고 복잡성이 증가할 수 있습니다. 필요할 때만 동기화를 사용하고 임계 영역을 가능한 한 짧게 유지하십시오.
• 항상 Lock 해제 (Always Release Locks): Lock 사용을 마친 후에는 항상 Lock을 해제해야 합니다. with 문을 사용하여 예외가 발생하더라도 Lock을 자동으로 획득하고 해제하십시오.
• 철저한 테스트 (Thorough Testing): 동시성 관련 문제를 식별하고 해결하기 위해 멀티스레드 코드를 철저히 테스트하십시오. 스레드 새니타이저 및 메모리 검사기와 같은 도구를 사용하여 잠재적인 문제를 탐지하십시오.

결론

Python 스레딩 프리미티브를 마스터하는 것은 강력하고 효율적인 동시성 애플리케이션을 구축하는 데 필수적입니다. Lock, RLock, Semaphore, Condition Variables의 목적과 사용법을 이해함으로써 스레드 동기화를 효과적으로 관리하고 경쟁 조건을 방지하며 일반적인 동시성 함정을 피할 수 있습니다. 특정 작업에 맞는 올바른 프리미티브를 선택하고, 모범 사례를 따르며, 스레드 안전성과 최적의 성능을 보장하기 위해 코드를 철저히 테스트하는 것을 잊지 마십시오. 동시성의 힘을 받아들이고 Python 애플리케이션의 잠재력을 최대한 발휘하십시오!