운영체제 프로세스와 스레드 완벽 가이드: 개념부터 실무 활용까지

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// Java에서 시스템 콜이 내부적으로 발생하는 예시
import java.io.*;

public class SystemCallExample {
    public static void main(String[] args) throws IOException {
        // 파일 열기 - 내부적으로 open() 시스템 콜 발생
        FileInputStream fis = new FileInputStream("data.txt");

        // 파일 읽기 - 내부적으로 read() 시스템 콜 발생
        byte[] buffer = new byte[1024];
        int bytesRead = fis.read(buffer);

        // 파일 닫기 - 내부적으로 close() 시스템 콜 발생
        fis.close();

        // 프로세스 생성 - 내부적으로 fork() + exec() 시스템 콜 발생
        ProcessBuilder pb = new ProcessBuilder("ls", "-la");
        Process process = pb.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class MemoryExample {
    // Data 영역 - 클래스 변수 (static)
    static int globalCounter = 0;
    static final String CONSTANT = "상수값";

    public static void main(String[] args) {
        // Stack 영역 - 지역 변수 (참조값)
        int localVar = 10;

        // Heap 영역 - new로 생성된 객체
        String name = new String("Hello");
        int[] array = new int[100];

        // Stack에는 참조(주소)가, Heap에는 실제 객체가 저장됨
        List<String> list = new ArrayList<>();  // list 참조 → Stack, ArrayList 객체 → Heap

        calculate(localVar);  // 새로운 스택 프레임 생성
    }

    // 함수 호출 시 새로운 스택 프레임이 생성됨
    static int calculate(int n) {
        int result = n * 2;  // Stack 영역
        int[] temp = new int[n];  // temp 참조 → Stack, 배열 객체 → Heap
        return result;  // 함수 반환 시 이 스택 프레임 제거
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class PCBExample {
    public static void main(String[] args) {
        // Java에서 현재 프로세스 정보 확인
        ProcessHandle current = ProcessHandle.current();

        System.out.println("PID: " + current.pid());
        System.out.println("명령어: " + current.info().command().orElse("N/A"));
        System.out.println("시작 시간: " + current.info().startInstant().orElse(null));
        System.out.println("CPU 시간: " + current.info().totalCpuDuration().orElse(null));
        System.out.println("사용자: " + current.info().user().orElse("N/A"));

        // 부모 프로세스 정보
        current.parent().ifPresent(parent -> {
            System.out.println("부모 PID: " + parent.pid());
            System.out.println("부모 명령어: " + parent.info().command().orElse("N/A"));
        });

        // 모든 프로세스 목록 조회
        ProcessHandle.allProcesses()
            .filter(ph -> ph.info().command().isPresent())
            .limit(10)
            .forEach(ph -> System.out.printf("PID: %d, CMD: %s%n",
                ph.pid(), ph.info().command().orElse("N/A")));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// Java에서 컨텍스트 스위칭 오버헤드 간접 측정
public class ContextSwitchBenchmark {
    public static void main(String[] args) throws Exception {
        final int ITERATIONS = 1_000_000;
        Object lock = new Object();

        long start = System.nanoTime();

        Thread t1 = new Thread(() -> {
            for (int i = 0; i < ITERATIONS; i++) {
                synchronized (lock) {
                    lock.notify();
                    try { lock.wait(); } catch (InterruptedException e) { break; }
                }
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < ITERATIONS; i++) {
                synchronized (lock) {
                    lock.notify();
                    try { lock.wait(); } catch (InterruptedException e) { break; }
                }
            }
        });

        t1.start();
        t2.start();
        t1.join();
        t2.join();

        long elapsed = System.nanoTime() - start;
        System.out.printf("총 소요 시간: %d ms%n", elapsed / 1_000_000);
        System.out.printf("스위칭당 평균: %d ns%n", elapsed / (ITERATIONS * 2));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 커널 스레드 (플랫폼 스레드) - 전통적인 방식
Thread platformThread = new Thread(() -> {
    System.out.println("플랫폼 스레드: " + Thread.currentThread());
});
platformThread.start();

// 가상 스레드 (Java 21+) - 경량 스레드
Thread virtualThread = Thread.ofVirtual().start(() -> {
    System.out.println("가상 스레드: " + Thread.currentThread());
});

// 가상 스레드 대량 생성 (10만 개도 가볍게)
try (var executor = java.util.concurrent.Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100_000; i++) {
        executor.submit(() -> {
            Thread.sleep(java.time.Duration.ofSeconds(1));
            return "done";
        });
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// 멀티프로세스 방식 - ProcessBuilder 사용
public class MultiProcessExample {
    public static void main(String[] args) throws Exception {
        List<Process> processes = new ArrayList<>();

        for (int i = 0; i < 4; i++) {
            ProcessBuilder pb = new ProcessBuilder(
                "java", "-cp", ".", "Worker", String.valueOf(i)
            );
            pb.inheritIO();
            processes.add(pb.start());
        }

        // 모든 프로세스 완료 대기
        for (Process p : processes) {
            int exitCode = p.waitFor();
            System.out.println("프로세스 종료 코드: " + exitCode);
        }
    }
}

// 멀티스레드 방식 - ExecutorService 사용
public class MultiThreadExample {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(4);
        List<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 4; i++) {
            final int taskId = i;
            futures.add(executor.submit(() -> {
                System.out.println("Task " + taskId + " 실행 중 - "
                    + Thread.currentThread().getName());
                Thread.sleep(1000);
                return "Task " + taskId + " 완료";
            }));
        }

        for (Future<String> future : futures) {
            System.out.println(future.get());
        }

        executor.shutdown();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Java에서 파이프를 통한 프로세스 간 통신
public class PipeExample {
    public static void main(String[] args) throws Exception {
        // ls의 출력을 grep으로 전달하는 파이프
        ProcessBuilder ls = new ProcessBuilder("ls", "-la");
        ProcessBuilder grep = new ProcessBuilder("grep", ".java");

        // Java 9+ 파이프라인
        List<Process> pipeline = ProcessBuilder.startPipeline(
            List.of(ls, grep)
        );

        // 마지막 프로세스의 출력 읽기
        Process last = pipeline.get(pipeline.size() - 1);
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(last.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
// Java NIO의 MappedByteBuffer를 통한 메모리 맵 파일 (공유 메모리와 유사)
import java.nio.*;
import java.nio.channels.*;
import java.io.*;

// 프로세스 1: 데이터 쓰기
public class SharedMemoryWriter {
    public static void main(String[] args) throws Exception {
        RandomAccessFile file = new RandomAccessFile("shared.dat", "rw");
        FileChannel channel = file.getChannel();

        // 메모리 맵 파일 생성 (1KB)
        MappedByteBuffer buffer = channel.map(
            FileChannel.MapMode.READ_WRITE, 0, 1024
        );

        // 데이터 쓰기
        buffer.putInt(42);
        buffer.putDouble(3.14159);
        buffer.put("Hello from Process 1".getBytes());

        System.out.println("데이터를 공유 메모리에 작성했습니다.");
        channel.close();
        file.close();
    }
}

// 프로세스 2: 데이터 읽기
public class SharedMemoryReader {
    public static void main(String[] args) throws Exception {
        RandomAccessFile file = new RandomAccessFile("shared.dat", "r");
        FileChannel channel = file.getChannel();

        MappedByteBuffer buffer = channel.map(
            FileChannel.MapMode.READ_ONLY, 0, 1024
        );

        int intValue = buffer.getInt();
        double doubleValue = buffer.getDouble();
        byte[] strBytes = new byte[20];
        buffer.get(strBytes);

        System.out.println("정수: " + intValue);
        System.out.println("실수: " + doubleValue);
        System.out.println("문자열: " + new String(strBytes).trim());

        channel.close();
        file.close();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// 서버 소켓
public class SocketServer {
    public static void main(String[] args) throws Exception {
        ServerSocket server = new ServerSocket(8080);
        System.out.println("서버 시작 - 포트 8080");

        while (true) {
            Socket client = server.accept();
            new Thread(() -> handleClient(client)).start();
        }
    }

    static void handleClient(Socket client) {
        try (BufferedReader in = new BufferedReader(
                new InputStreamReader(client.getInputStream()));
             PrintWriter out = new PrintWriter(
                client.getOutputStream(), true)) {

            String message = in.readLine();
            System.out.println("수신: " + message);
            out.println("서버 응답: " + message.toUpperCase());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class RaceConditionExample {
    private static int counter = 0;

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 100_000; i++) counter++;
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 100_000; i++) counter++;
        });

        t1.start(); t2.start();
        t1.join(); t2.join();

        // 기대값: 200,000이지만 실제로는 더 작은 값이 나옴
        System.out.println("Counter: " + counter);  // 예: 156,832
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Java의 ReentrantLock = Mutex
import java.util.concurrent.locks.ReentrantLock;

public class MutexExample {
    private final ReentrantLock mutex = new ReentrantLock();
    private int sharedResource = 0;

    public void increment() {
        mutex.lock();
        try {
            sharedResource++;  // 임계 영역
        } finally {
            mutex.unlock();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    // 최대 3개 스레드 동시 접근 가능
    private final Semaphore semaphore = new Semaphore(3);

    public void accessResource(int threadId) {
        try {
            semaphore.acquire();  // 카운터 감소 (P 연산)
            System.out.println("Thread " + threadId + " 진입 (허가: "
                + semaphore.availablePermits() + ")");
            Thread.sleep(2000);  // 자원 사용
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            semaphore.release();  // 카운터 증가 (V 연산)
            System.out.println("Thread " + threadId + " 퇴장");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Java synchronized = Monitor
public class MonitorExample {
    private final Queue<Integer> buffer = new LinkedList<>();
    private final int MAX_SIZE = 10;

    public synchronized void produce(int item) throws InterruptedException {
        while (buffer.size() == MAX_SIZE) {
            wait();  // 버퍼가 가득 차면 대기
        }
        buffer.add(item);
        System.out.println("생산: " + item + " (버퍼 크기: " + buffer.size() + ")");
        notifyAll();  // 대기 중인 소비자 깨우기
    }

    public synchronized int consume() throws InterruptedException {
        while (buffer.isEmpty()) {
            wait();  // 버퍼가 비면 대기
        }
        int item = buffer.poll();
        System.out.println("소비: " + item + " (버퍼 크기: " + buffer.size() + ")");
        notifyAll();  // 대기 중인 생산자 깨우기
        return item;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
// 데드락 발생 예제
public class DeadlockExample {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("Thread 1: lockA 획득");
                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread 1: lockB 대기...");
                synchronized (lockB) {  // lockB를 기다림 → 데드락!
                    System.out.println("Thread 1: lockB 획득");
                }
            }
        });

        Thread t2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("Thread 2: lockB 획득");
                try { Thread.sleep(100); } catch (InterruptedException e) {}

                System.out.println("Thread 2: lockA 대기...");
                synchronized (lockA) {  // lockA를 기다림 → 데드락!
                    System.out.println("Thread 2: lockA 획득");
                }
            }
        });

        t1.start();
        t2.start();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// 데드락 예방 - Lock 순서 통일
public class DeadlockPrevention {
    private static final Object lockA = new Object();  // 순서 1
    private static final Object lockB = new Object();  // 순서 2

    // 항상 lockA → lockB 순서로 획득
    public static void method1() {
        synchronized (lockA) {
            synchronized (lockB) {
                System.out.println("안전한 실행");
            }
        }
    }

    // 마찬가지로 lockA → lockB 순서
    public static void method2() {
        synchronized (lockA) {
            synchronized (lockB) {
                System.out.println("안전한 실행");
            }
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Java에서 데드락 탐지
import java.lang.management.*;

public class DeadlockDetector {
    public static void detectDeadlock() {
        ThreadMXBean threadBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadBean.findDeadlockedThreads();

        if (deadlockedThreads != null) {
            System.out.println("데드락 발견!");
            ThreadInfo[] threadInfos = threadBean.getThreadInfo(deadlockedThreads, true, true);
            for (ThreadInfo info : threadInfos) {
                System.out.println("스레드: " + info.getThreadName());
                System.out.println("상태: " + info.getThreadState());
                System.out.println("대기 중인 락: " + info.getLockName());
                System.out.println("락 소유자: " + info.getLockOwnerName());
                System.out.println("---");
            }
        } else {
            System.out.println("데드락 없음");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
public class DiningPhilosophers {
    private static final int NUM = 5;
    private static final ReentrantLock[] chopsticks = new ReentrantLock[NUM];

    static {
        for (int i = 0; i < NUM; i++) {
            chopsticks[i] = new ReentrantLock();
        }
    }

    static class Philosopher extends Thread {
        private final int id;

        Philosopher(int id) { this.id = id; this.setName("철학자-" + id); }

        public void run() {
            try {
                while (!Thread.interrupted()) {
                    think();
                    eat();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        void think() throws InterruptedException {
            System.out.println(getName() + " 생각 중...");
            Thread.sleep((long) (Math.random() * 1000));
        }

        void eat() throws InterruptedException {
            // 데드락 방지: 항상 번호가 작은 젓가락 먼저 집기
            int first = Math.min(id, (id + 1) % NUM);
            int second = Math.max(id, (id + 1) % NUM);

            chopsticks[first].lock();
            chopsticks[second].lock();
            try {
                System.out.println(getName() + " 식사 중 🍝");
                Thread.sleep((long) (Math.random() * 1000));
            } finally {
                chopsticks[second].unlock();
                chopsticks[first].unlock();
            }
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < NUM; i++) {
            new Philosopher(i).start();
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class ProcessManagement {
    public static void main(String[] args) throws Exception {
        // 외부 프로세스 실행
        ProcessBuilder builder = new ProcessBuilder("ping", "-c", "3", "google.com");
        builder.redirectErrorStream(true);  // 에러 스트림을 표준 출력으로 합침

        Process process = builder.start();

        // 출력 읽기
        try (BufferedReader reader = new BufferedReader(
                new InputStreamReader(process.getInputStream()))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        }

        int exitCode = process.waitFor();
        System.out.println("종료 코드: " + exitCode);

        // 타임아웃 설정
        ProcessBuilder pb2 = new ProcessBuilder("sleep", "30");
        Process p2 = pb2.start();
        boolean finished = p2.waitFor(5, java.util.concurrent.TimeUnit.SECONDS);
        if (!finished) {
            p2.destroyForcibly();
            System.out.println("프로세스 강제 종료됨");
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.util.concurrent.*;

public class ThreadPoolExample {
    public static void main(String[] args) throws Exception {
        // 고정 크기 스레드풀
        ExecutorService pool = Executors.newFixedThreadPool(
            Runtime.getRuntime().availableProcessors()
        );

        // CompletableFuture를 활용한 비동기 처리
        CompletableFuture<String> future = CompletableFuture
            .supplyAsync(() -> {
                // 비동기로 사용자 정보 조회
                return fetchUser("user123");
            }, pool)
            .thenApplyAsync(user -> {
                // 사용자의 주문 목록 조회
                return fetchOrders(user);
            }, pool)
            .thenApplyAsync(orders -> {
                // 주문 요약 생성
                return createSummary(orders);
            }, pool)
            .exceptionally(ex -> {
                System.err.println("에러 발생: " + ex.getMessage());
                return "기본 요약";
            });

        String result = future.get(10, TimeUnit.SECONDS);
        System.out.println("결과: " + result);

        pool.shutdown();
    }

    static String fetchUser(String id) { return "User-" + id; }
    static String fetchOrders(String user) { return user + "-orders"; }
    static String createSummary(String orders) { return "Summary: " + orders; }
}