동시성 제어와 동기화: 뮤텍스부터 Actor 모델까지

[프로세스 A]              [프로세스 B]
┌──────────┐             ┌──────────┐
│  Stack   │             │  Stack   │
│  Heap    │  ← 독립적 →  │  Heap    │
│  Data    │             │  Data    │
│  Text    │             │  Text    │
└──────────┘             └──────────┘
 
[스레드 1]   [스레드 2]   ← 같은 프로세스 내
┌────────┐  ┌────────┐
│ Stack  │  │ Stack  │   ← 각 스레드 독립 스택
└────────┘  └────────┘
     ↕ 공유 ↕
┌────────────────────┐
│   Heap (공유)       │   ← 여기서 동시성 문제 발생
│   Data (공유)       │
│   Text (공유)       │
└────────────────────┘

# 경쟁 조건 예시: 은행 잔고 업데이트
balance = 1000
 
# 스레드 A: 출금 500
temp_a = balance        # 1000 읽음
temp_a = temp_a - 500   # 500 계산
 
# 스레드 B: 출금 300 (A가 쓰기 전에 읽음)
temp_b = balance        # 1000 읽음 (아직 A의 결과 반영 안됨)
temp_b = temp_b - 300   # 700 계산
 
balance = temp_a        # 500 저장
balance = temp_b        # 700 저장 (A의 출금이 사라짐!)
# 기대값: 200, 실제값: 700

// Go에서의 Mutex 사용
var mu sync.Mutex
var balance int = 1000
 
func withdraw(amount int) {
    mu.Lock()           // 잠금 획득
    defer mu.Unlock()   // 함수 종료 시 잠금 해제
 
    if balance >= amount {
        balance -= amount
    }
}

# Python에서의 Semaphore 사용
# DB 연결 풀: 최대 5개 동시 연결
db_pool = threading.Semaphore(5)
 
def query_database(sql):
    db_pool.acquire()   # 카운터 감소 (0이면 블로킹)
    try:
        connection = get_connection()
        return connection.execute(sql)
    finally:
        db_pool.release()  # 카운터 증가

Mutex: 화장실 열쇠 (1개)
  → 한 사람만 들어갈 수 있고, 그 사람만 나올 때 열쇠 반환
 
Semaphore: 주차장 카운터 (N개)
  → N대까지 입장 가능, 아무나 나가면 카운터 증가
  → 소유권 개념 없음

// Java의 Monitor (synchronized + wait/notify)
class BoundedBuffer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity;
 
    synchronized void produce(int item) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();  // 버퍼가 가득 차면 대기
        }
        queue.add(item);
        notifyAll();  // 소비자에게 신호
    }
 
    synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();  // 버퍼가 비었으면 대기
        }
        int item = queue.poll();
        notifyAll();  // 생산자에게 신호
        return item;
    }
}

교착 상태 예시:
  스레드 A: Lock(X) 획득 → Lock(Y) 대기
  스레드 B: Lock(Y) 획득 → Lock(X) 대기
 
     A ──가지고있음──→ X
     ↑                ↓ 대기
     대기              B
     ↓                ↑
     Y ←──가지고있음── B

# 순환 대기 예방: Lock을 항상 같은 순서로 획득
LOCK_ORDER = {'account_lock': 1, 'transaction_lock': 2}
 
def transfer(from_acc, to_acc, amount):
    # 항상 ID가 작은 계좌의 lock을 먼저 획득
    first, second = sorted([from_acc, to_acc], key=lambda a: a.id)
    with first.lock:
        with second.lock:
            from_acc.balance -= amount
            to_acc.balance += amount

// Go의 RWMutex
var rwmu sync.RWMutex
var data map[string]string
 
func read(key string) string {
    rwmu.RLock()          // 읽기 잠금 (여러 고루틴 동시 가능)
    defer rwmu.RUnlock()
    return data[key]
}
 
func write(key, value string) {
    rwmu.Lock()           // 쓰기 잠금 (배타적)
    defer rwmu.Unlock()
    data[key] = value
}

CAS(address, expected_value, new_value):
    if *address == expected_value:
        *address = new_value
        return true
    else:
        return false

// Java의 AtomicInteger -- CAS 기반
AtomicInteger counter = new AtomicInteger(0);
 
// Lock 없이 안전한 증가
counter.incrementAndGet();
 
// CAS 직접 사용
int expected = counter.get();
boolean success = counter.compareAndSet(expected, expected + 1);

// Go Channel을 통한 안전한 통신
func main() {
    ch := make(chan int, 10)  // 버퍼 채널
 
    // 생산자 고루틴
    go func() {
        for i := 0; i < 100; i++ {
            ch <- i  // 채널에 전송
        }
        close(ch)
    }()
 
    // 소비자: 채널에서 수신
    for v := range ch {
        fmt.Println(v)
    }
}

use std::thread;
use std::sync::{Arc, Mutex};
 
fn main() {
    // Arc: Atomic Reference Counting (스레드 안전한 참조 카운팅)
    // Mutex: 내부 데이터 보호
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
 
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
}

// Node.js의 비동기 모델
async function handleRequest(req) {
    // I/O 대기 중 이벤트 루프가 다른 요청 처리
    const user = await db.findUser(req.userId);
    const orders = await db.findOrders(user.id);
 
    // 병렬 실행
    const [profile, notifications] = await Promise.all([
        fetchProfile(user.id),
        fetchNotifications(user.id)
    ]);
 
    return { user, orders, profile, notifications };
}

사용자 공간                         커널 공간
┌───────────────┐               ┌───────────────┐
│ Submission    │  ← mmap() →  │               │
│ Queue (SQ)    │  공유 메모리   │  Kernel       │
│  SQE1, SQE2..│               │  I/O 처리     │
└───────────────┘               │               │
                                │               │
┌───────────────┐               │               │
│ Completion    │  ← mmap() →  │               │
│ Queue (CQ)    │  공유 메모리   │               │
│  CQE1, CQE2..│               └───────────────┘
└───────────────┘
 
SQE: Submission Queue Entry (요청)
CQE: Completion Queue Entry (결과)

// io_uring 기본 사용 예시 (개념적)
struct io_uring ring;
io_uring_queue_init(32, &ring, 0);
 
// 읽기 요청 제출
struct io_uring_sqe *sqe = io_uring_get_sqe(&ring);
io_uring_prep_read(sqe, fd, buf, size, offset);
io_uring_submit(&ring);
 
// 완료 결과 수신
struct io_uring_cqe *cqe;
io_uring_wait_cqe(&ring, &cqe);
int bytes_read = cqe->res;
io_uring_cqe_seen(&ring, cqe);

요청 1 ──→ ┌──────────────┐ ──→ DB 연결 1
요청 2 ──→ │ Connection   │ ──→ DB 연결 2
요청 3 ──→ │ Pool (N=5)   │ ──→ DB 연결 3
요청 4 ──→ │              │ ──→ DB 연결 4
요청 5 ──→ │ Semaphore(5) │ ──→ DB 연결 5
요청 6 ──→ └──────────────┘ ──→ 대기... (블로킹)