스레드와 동기화에 관하여

시간 →
스레드 1: [실행]---[대기]------------[실행]---
                   ↓      ↑
스레드 2: ---[대기]---[실행]---[대기]-------
                         ↓      ↑
스레드 3: -------[대기]------------[실행]---

문맥 전환: PC 레지스터 값이 저장되고 복원됨

// 전통적인 프로세스 생성과 유사
clone(0, ...);

// 전통적인 스레드 생성과 유사
clone(CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ...);

// 하이브리드: 메모리 공유하지만 파일은 독립적
clone(CLONE_VM, ...);

초기 합계: 10
producer, consumer 스레드 실행 이후 합계: -38292

프로세스A         프로세스B      현재 sum   현재 r1   현재 r2
-------------------------------------------------------------
r1 = sum                     |   10        10
r1 = r1 + 1                  |   10        11
문맥교환                      |   10        11
                 r2 = sum    |   10        11        10
                 r2 = r2 -1  |   10        11         9
                 문맥교환     |   10        11         9
sum = r1                     |   11        11         9
문맥 교환                     |   11        11         9
                 sum = r2    |    9        11         9

트랜잭션 A: 테이블1 잠금 → 테이블2 잠금 요청 → 대기(교착 상태)
트랜잭션 B: 테이블2 잠금 → 테이블1 잠금 요청 → 대기(교착 상태)

트랜잭션 A: 테이블1(ID=1) 잠금 → 테이블2(ID=2) 잠금 요청 → 획득 → 작업 완료

트랜잭션 B: 테이블1(ID=1) 잠금 요청 → 대기 → 트랜잭션 A 완료 후 획득 → 테이블2 잠금 → 작업 완료

작업 A: 현재 4GB 메모리 사용 중, 최대 8GB 필요
작업 B: 현재 6GB 메모리 사용 중, 최대 10GB 필요
총 가용 메모리: 12GB

작업 B가 2GB 추가 요청 → 가상 승인 결과: 남은 메모리 4GB(작업 A의 최대 요구량 채우기 불가능) → 불안전 상태 → 요청 거부

작업 A가 추가 2GB 요청 → 가상 승인 결과: 남은 메모리 6GB(작업 B 최대 요구량 채우기 가능) → 안전 상태 → 요청 승인

서비스 A: 서비스 B에 요청 전송 → 응답 대기 중
서비스 B: 서비스 C에 요청 전송 → 응답 대기 중
서비스 C: 서비스 A에 요청 전송 → 응답 대기 중 (교착 상태 발생)

서비스 C의 요청이 타임아웃 → 서비스 C는 오류 응답 반환 → 서비스 B가 해당 응답 처리 → 서비스 A에 응답 → 순환 고리 끊김

이후 서비스 C는 잠시 대기 후 서비스 A에 다시 요청 → 이번에는 서비스 A가 응답 가능 → 정상 처리

#include <iostream>
#include <queue>
#include <thread>

void produce();
void consume();

int sum = 10;
void produce() {
  for(int i = 0; i < 100000; i++) {
    sum++;
  }
}

void consume() {
  for(int i = 0; i < 100000; i++) {
    sum--;
  }
}

int main() {
  std::cout << "초기 합계: " <<  sum << std::endl;
  std::thread producer(produce);
  std::thread consumer(consume);

  producer.join();
  consumer.join();
  std::cout << "producer, consumer 스레드 실행 이후 합계: " <<  sum << std::endl;
  return 0;
}

#include <mutex>

std::mutex sum_mutex; // sum 변수를 보호할 뮤텍스를 선언합니다.

void produce() {
  for(int i = 0; i < 100000; i++) {
    sum_mutex.lock();
    sum++;
    sum_mutex.unlock();
  }
}