프로세스 동기화

#include <stdio.h>
#include <pthread.h>

static int            counter = 0;
static pthread_mutex_t mtx     = PTHREAD_MUTEX_INITIALIZER;

void *worker(void *arg) {
    for (int i = 0; i < 100000; i++) {

        pthread_mutex_lock(&mtx);    // 임계 구역 진입
        counter++;                   // 읽기 → 증가 → 쓰기 (원자적 보장)
        pthread_mutex_unlock(&mtx);  // 임계 구역 탈출
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, worker, NULL);
    pthread_create(&t2, NULL, worker, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("counter = %d (expected 200000)\n", counter);
    pthread_mutex_destroy(&mtx);
    return 0;
}

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>

#define BUF_SIZE 5

int  buffer[BUF_SIZE];
int  in  = 0, out = 0;

sem_t empty;   // 빈 슬롯 수 (초기값: BUF_SIZE)
sem_t full;    // 찬 슬롯 수 (초기값: 0)
pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

void *producer(void *arg) {
    for (int i = 0; i < 10; i++) {
        sem_wait(&empty);            // 빈 슬롯 대기 (empty--)
        pthread_mutex_lock(&mtx);
        buffer[in] = i;
        in = (in + 1) % BUF_SIZE;
        pthread_mutex_unlock(&mtx);
        sem_post(&full);             // 찬 슬롯 증가 (full++)
    }
    return NULL;
}

void *consumer(void *arg) {
    for (int i = 0; i < 10; i++) {
        sem_wait(&full);             // 찬 슬롯 대기 (full--)
        pthread_mutex_lock(&mtx);
        int item = buffer[out];
        out = (out + 1) % BUF_SIZE;
        pthread_mutex_unlock(&mtx);
        sem_post(&empty);            // 빈 슬롯 증가 (empty++)
        printf("consumed: %d\n", item);
    }
    return NULL;
}

int main() {
    sem_init(&empty, 0, BUF_SIZE);  // 빈 슬롯 5개
    sem_init(&full,  0, 0);         // 찬 슬롯 0개
    pthread_t p, c;
    pthread_create(&p, NULL, producer, NULL);
    pthread_create(&c, NULL, consumer, NULL);
    pthread_join(p, NULL);
    pthread_join(c, NULL);
    sem_destroy(&empty);
    sem_destroy(&full);
    return 0;
}

import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.atomic.AtomicInteger;

public class SyncDemo {

    // 방법 1: synchronized — Monitor 기반, 가장 단순
    private int counter1 = 0;
    public synchronized void increment1() {
        counter1++;   // 메서드 전체가 임계 구역
    }

    // 방법 2: ReentrantLock — 세밀한 제어, tryLock / fairness 지원
    private int           counter2 = 0;
    private final ReentrantLock lock = new ReentrantLock(true); // fair lock

    public void increment2() {
        lock.lock();
        try {
            counter2++;   // 임계 구역
        } finally {
            lock.unlock();  // 예외 발생해도 반드시 해제 (RAII 대체)
        }
    }

    // 방법 3: AtomicInteger — CAS 기반 Lock-Free, 가장 고성능
    private final AtomicInteger counter3 = new AtomicInteger(0);

    public void increment3() {
        counter3.incrementAndGet();  // CAS 원자 명령어 → 락 불필요
    }

    public static void main(String[] args) throws Exception {
        SyncDemo demo = new SyncDemo();

        // 두 스레드가 각 메서드를 10만 번씩 호출
        Runnable r1 = () -> { for (int i=0;i<100_000;i++) demo.increment1(); };
        Runnable r2 = () -> { for (int i=0;i<100_000;i++) demo.increment2(); };
        Runnable r3 = () -> { for (int i=0;i<100_000;i++) demo.increment3(); };

        Thread[] ts = {
            new Thread(r1), new Thread(r1),
            new Thread(r2), new Thread(r2),
            new Thread(r3), new Thread(r3),
        };
        for (Thread t : ts) t.start();
        for (Thread t : ts) t.join();

        System.out.println("synchronized : "  + demo.counter1); // 200000
        System.out.println("ReentrantLock: "  + demo.counter2); // 200000
        System.out.println("AtomicInteger: "  + demo.counter3.get()); // 200000
    }
}