스레드

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

// 공유 자원 — 여러 스레드가 동시에 접근하면 Race Condition 발생
static int            counter = 0;
static pthread_mutex_t mtx     = PTHREAD_MUTEX_INITIALIZER;

void *worker(void *arg) {
    int id = *(int *)arg;
    for (int i = 0; i < 100000; i++) {
        // 임계 구역(Critical Section) 진입 전 Lock 획득
        pthread_mutex_lock(&mtx);
        counter++;  // 원자적이지 않은 read-modify-write → Lock 필수
        pthread_mutex_unlock(&mtx);
    }
    printf("Thread %d done\n", id);
    return NULL;
}

int main() {
    const int N = 4;
    pthread_t  threads[N];
    int        ids[N];

    // 스레드 생성: 각 스레드는 독립 Stack + PC 를 가지고
    // counter / mtx 를 공유함 (Code·Data·Heap 공유)
    for (int i = 0; i < N; i++) {
        ids[i] = i;
        pthread_create(&threads[i], NULL, worker, &ids[i]);
    }

    // join(): 스레드 종료 대기 + 자원 회수 (프로세스의 wait()에 해당)
    for (int i = 0; i < N; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Final counter: %d (expected %d)\n", counter, N * 100000);
    pthread_mutex_destroy(&mtx);
    return 0;
}

import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadDemo {

    // AtomicInteger: CAS(Compare-And-Swap) 기반 락-프리 원자 연산
    private static final AtomicInteger counter = new AtomicInteger(0);

    // volatile: happens-before 관계 보장 (가시성 + 재정렬 금지)
    // 단, 복합 연산(i++)의 원자성은 보장하지 않음
    private static volatile boolean running = true;

    public static void main(String[] args) throws Exception {

        // 스레드 풀: 최대 4개 스레드를 재사용
        ExecutorService pool = Executors.newFixedThreadPool(4);

        for (int i = 0; i < 4; i++) {
            final int id = i;
            pool.submit(() -> {               // Callable / Runnable 제출
                for (int j = 0; j < 100_000; j++) {
                    counter.incrementAndGet(); // 원자적 증가
                }
                System.out.println("Worker " + id + " done");
            });
        }

        // shutdown(): 새 작업 제출 거부 + 기존 작업 완료 후 종료
        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);

        System.out.println("Final: " + counter.get()); // 400000

        // 가상 스레드 (Java 21, Project Loom, JEP 444)
        // JVM이 carrier thread 위에 M:N으로 스케줄링 — 수백만 개 생성 가능
        try (var vtPool = Executors.newVirtualThreadPerTaskExecutor()) {
            Future<String> future = vtPool.submit(() -> {
                Thread.sleep(100);      // I/O·sleep 블로킹 시 carrier에서 unmount
                return "virtual thread result";
            });
            System.out.println(future.get());
        }
    }
}