Concurrency

// Writer 프로세스
write_data_to_file();
send_completion_signal();  // 완료 신호
 
// Reader 프로세스  
wait_for_completion();     // 완료 대기
read_data_from_file();

Producer() {
    버퍼에 데이터 삽입
    '총합' 변수 1 증가
}
 
Consumer() {
    버퍼에서 데이터 빼내기
    '총합' 변수 1 감소
}

#include <stdio.h>
#include <pthread.h>
 
#define LOOP_COUNT 1000000
 
int sum = 0;
 
void* produce(void* arg);
void* consume(void* arg);
 
int main() {
    printf("초기 합계: %d\n", sum);
 
    pthread_t producer, consumer;
 
    pthread_create(&producer, NULL, produce, NULL);
    pthread_create(&consumer, NULL, consume, NULL);
 
    pthread_join(producer, NULL);
    pthread_join(consumer, NULL);
 
    printf("producer, consumer 스레드 실행 이후 합계: %d\n", sum);
    return 0;
}
 
void* produce(void* arg) {
    for (int i = 0; i < LOOP_COUNT; i++) {
        sum++;  // Race Condition 발생!
    }
    return NULL;
}
 
void* consume(void* arg) {
    for (int i = 0; i < LOOP_COUNT; i++) {
        sum--;  // Race Condition 발생!
    }
    return NULL;
}

gcc -o race_condition race_condition.c -pthread
./race_condition

#include <stdio.h>
#include <pthread.h>
 
#define QUEUE_SIZE 100000
 
int queue[QUEUE_SIZE];  // 공유 자원 - 생산자와 소비자가 공유하는 큐
int front = 0;          // 큐의 맨 앞 인덱스 (소비자가 데이터를 가져갈 위치)
int rear = 0;           // 큐의 맨 뒤 인덱스 (생산자가 데이터를 넣을 위치)
int count = 0;          // 현재 큐에 있는 항목의 개수
int sum = 0;            // 생산/소비 작업의 균형을 확인하기 위한 합계 변수
 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; // 뮤텍스 초기화
 
void* produce(void* arg); // 생산자 스레드 함수
void* consume(void* arg); // 소비자 스레드 함수
 
int main() {
    printf("초기 합계: %d\n", sum);
 
    pthread_t producer, consumer;
 
    // 생산자와 소비자 스레드 생성
    pthread_create(&producer, NULL, produce, NULL);
    pthread_create(&consumer, NULL, consume, NULL);
 
    // 생성된 스레드들이 종료될 때까지 대기
    pthread_join(producer, NULL);
    pthread_join(consumer, NULL);
 
    // 최종 결과 출력
    printf("producer, consumer 스레드 실행 이후 합계: %d\n", sum);
    printf("queue size: %d\n", count);
    return 0;
}
 
// 생산자 스레드 함수
void* produce(void* arg) {
    for(int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&mutex);    // 뮤텍스 잠금 - 임계 영역 시작
 
        if(count < QUEUE_SIZE) {       // 큐가 가득 차지 않았다면
            queue[rear] = 1;           // 큐의 rear 위치에 1 삽입
            rear = (rear + 1) % QUEUE_SIZE; // rear 포인터 이동 (원형 큐)
            count++;                   // 큐 항목 수 증가
            sum++;                     // 총합 증가
        }
 
        pthread_mutex_unlock(&mutex);  // 뮤텍스 해제 - 임계 영역 종료
    }
    return NULL;
}
 
// 소비자 스레드 함수
void* consume(void* arg) {
    for(int i = 0; i < 100000; i++) {
        pthread_mutex_lock(&mutex);    // 뮤텍스 잠금 - 임계 영역 시작
 
        if(count > 0) {                // 큐가 비어있지 않다면
            front = (front + 1) % QUEUE_SIZE; // front 포인터 이동 (원형 큐)
            count--;                   // 큐 항목 수 감소
            sum--;                     // 총합 감소
        }
 
        pthread_mutex_unlock(&mutex);  // 뮤텍스 해제 - 임계 영역 종료
    }
    return NULL;
}

// 임계 구역 예시
int shared_counter = 0;
 
void increment() {
    // ↓ 임계 구역 시작
    shared_counter++;  // 이 부분이 원자적으로 실행되어야 함
    // ↑ 임계 구역 끝
}

// 올바른 상호 배제
pthread_mutex_lock(&mutex);
shared_resource++;     // 한 번에 하나의 스레드만 접근
pthread_mutex_unlock(&mutex);

acquire();  // 임계구역이 잠겨있는지 확인, 잠겨있지 않다면 들어가서 잠그기
// 임계구역    // 임계구역에서의 작업 수행
release();  // 잠긴 임계구역을 열기

// 바쁜 대기의 예
while (lock == true) {
    // 계속 확인... CPU 낭비
}
lock = true;  // 임계 구역 진입

wait();     // S 감소, 자원 확보
// 임계구역
signal();   // S 증가, 자원 해제

// Process A (먼저 실행되어야 함)
do_work_first();
signal(sync_sem);
 
// Process B (나중에 실행되어야 함)  
wait(sync_sem);
do_work_second();

// 모니터 예시 (Java-style)
class BankAccount {
    private int balance = 0;
    private final Object lock = new Object();
 
    public void deposit(int amount) {
        synchronized(lock) {        // 자동 동기화
            balance += amount;
        }
    }
 
    public void withdraw(int amount) {
        synchronized(lock) {        // 자동 동기화
            balance -= amount;
        }
    }
}

#include <pthread.h>
#include <semaphore.h>
 
#define BUFFER_SIZE 10
 
int buffer[BUFFER_SIZE];
int in = 0, out = 0;
 
sem_t empty, full;
pthread_mutex_t mutex;
 
void* producer(void* arg) {
    int item;
    while (1) {
        item = produce_item();
 
        sem_wait(&empty);           // 빈 슬롯 대기
        pthread_mutex_lock(&mutex); // 버퍼 접근 보호
 
        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;
 
        pthread_mutex_unlock(&mutex);
        sem_post(&full);            // 채워진 슬롯 증가
    }
}
 
void* consumer(void* arg) {
    int item;
    while (1) {
        sem_wait(&full);            // 채워진 슬롯 대기
        pthread_mutex_lock(&mutex); // 버퍼 접근 보호
 
        item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
 
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);           // 빈 슬롯 증가
 
        consume_item(item);
    }
}

#include <pthread.h>
#include <semaphore.h>
 
int readers_count = 0;
sem_t write_mutex, read_count_mutex;
 
void* reader(void* arg) {
    while (1) {
        sem_wait(&read_count_mutex);
        readers_count++;
        if (readers_count == 1) {
            sem_wait(&write_mutex);  // 첫 번째 리더가 쓰기 차단
        }
        sem_post(&read_count_mutex);
 
        // 읽기 작업
        read_data();
 
        sem_wait(&read_count_mutex);
        readers_count--;
        if (readers_count == 0) {
            sem_post(&write_mutex);  // 마지막 리더가 쓰기 허용
        }
        sem_post(&read_count_mutex);
    }
}
 
void* writer(void* arg) {
    while (1) {
        sem_wait(&write_mutex);
 
        // 쓰기 작업 (배타적 접근)
        write_data();
 
        sem_post(&write_mutex);
    }
}

// 나쁜 예: 락 보유 시간이 김
pthread_mutex_lock(&mutex);
do_heavy_computation();  // 오래 걸리는 작업
shared_data++;
pthread_mutex_unlock(&mutex);
 
// 좋은 예: 락 보유 시간 최소화
int result = do_heavy_computation();
pthread_mutex_lock(&mutex);
shared_data += result;
pthread_mutex_unlock(&mutex);

// 항상 같은 순서로 락 획득
void transfer(Account* from, Account* to, int amount) {
    Account* first = (from < to) ? from : to;
    Account* second = (from < to) ? to : from;
 
    pthread_mutex_lock(&first->mutex);
    pthread_mutex_lock(&second->mutex);
 
    // 송금 작업
 
    pthread_mutex_unlock(&second->mutex);
    pthread_mutex_unlock(&first->mutex);
}

#include <stdatomic.h>
 
atomic_int counter = 0;
 
void increment() {
    atomic_fetch_add(&counter, 1);  // 락 없이 원자적 증가
}