스레드 기초 — Thread, Runnable, 그리고 동기화의 시작

프로세스 A
├── 스레드 1 (스택 독립)
├── 스레드 2 (스택 독립)
└── 힙 메모리 (공유!)

class MyThread extends Thread {
    @Override
    public void run() {
        // 새 스레드에서 실행될 코드
        System.out.println("스레드 이름: " + getName());
    }
}

MyThread t = new MyThread();
t.start(); // 새 스레드 시작

class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable: " + Thread.currentThread().getName());
    }
}

Thread t = new Thread(new MyRunnable());
t.start();

Thread t = new Thread(() -> {
    System.out.println("람다로 생성한 스레드: " + Thread.currentThread().getName());
});
t.start();

Thread t = new Thread(() -> {
    System.out.println("실행 스레드: " + Thread.currentThread().getName());
});

t.run();   // 출력: 실행 스레드: main ← 새 스레드가 아님!
t.start(); // 출력: 실행 스레드: Thread-0 ← 새 스레드에서 실행

        start()
NEW ──────────→ RUNNABLE ──────→ TERMINATED
                  ↑   |
                  |   | synchronized 락 대기
                  |   ↓
                  | BLOCKED
                  |
                  | wait(), join()
                  ↓
                WAITING
                  |
                  | sleep(ms), wait(ms), join(ms)
                  ↓
              TIMED_WAITING

Thread t = new Thread(() -> {
    try {
        Thread.sleep(1000); // TIMED_WAITING 상태
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

System.out.println(t.getState()); // NEW
t.start();
System.out.println(t.getState()); // RUNNABLE (또는 TIMED_WAITING)

System.out.println("작업 시작");
Thread.sleep(2000); // 2초 대기 (TIMED_WAITING 상태)
System.out.println("2초 후 재개");

Thread worker = new Thread(() -> {
    try {
        Thread.sleep(2000);
        System.out.println("작업 완료");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
});

worker.start();
System.out.println("worker 스레드 시작됨");

worker.join(); // worker가 끝날 때까지 main 스레드가 대기
System.out.println("worker 종료 확인, 다음 작업 진행");

worker 스레드 시작됨
작업 완료
worker 종료 확인, 다음 작업 진행

// 타임아웃 설정도 가능
worker.join(5000); // 최대 5초만 대기

Thread longTask = new Thread(() -> {
    while (!Thread.currentThread().isInterrupted()) {
        System.out.println("작업 중...");
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // sleep 중 interrupt되면 여기로 온다
            System.out.println("인터럽트 받음, 정리하고 종료");
            Thread.currentThread().interrupt(); // 인터럽트 상태 복원
            break;
        }
    }
    System.out.println("스레드 종료");
});

longTask.start();
Thread.sleep(2000);
longTask.interrupt(); // 2초 후 중단 신호

class Counter {
    private int count = 0;

    public void increment() {
        count++; // 이 한 줄이 문제다
    }

    public int getCount() {
        return count;
    }
}

Counter counter = new Counter();

// 스레드 2개가 각각 10000번씩 increment
Thread t1 = new Thread(() -> {
    for (int i = 0; i < 10000; i++) counter.increment();
});
Thread t2 = new Thread(() -> {
    for (int i = 0; i < 10000; i++) counter.increment();
});

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

System.out.println("결과: " + counter.getCount());
// 기대값: 20000
// 실제값: 17834 (실행할 때마다 다름!)

스레드1: read(count=5) → add(5+1=6) → write(count=6)
스레드2: read(count=5) → add(5+1=6) → write(count=6)
         ↑ 같은 값을 읽음!         결과: 1만 증가됨

class Counter {
    private int count = 0;

    // synchronized 메서드 — this 객체의 락을 잡는다
    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

class Counter {
    private int count = 0;
    private final Object lock = new Object(); // 락 전용 객체

    public void increment() {
        // 이 블록 안에서만 동기화
        synchronized (lock) {
            count++;
        }
    }
}

// 인스턴스 락 — 같은 객체에 대해서만 동기화
public synchronized void instanceMethod() { }

// 클래스 락 — 모든 인스턴스에 걸쳐 동기화
public static synchronized void classMethod() { }

class StopFlag {
    private boolean running = true; // volatile 없음

    public void stop() {
        running = false;
    }

    public void run() {
        while (running) {
            // 작업 수행
        }
        System.out.println("종료");
    }
}

메인 메모리: running = false  (stop()이 변경)
스레드 캐시: running = true   (아직 이전 값을 보고 있음!)

private volatile boolean running = true;

private volatile int count = 0;

// 이것은 여전히 안전하지 않다!
count++; // Read → Modify → Write (3단계)

class SharedQueue {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int MAX_SIZE = 5;

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

    // 소비자: 큐가 비면 대기
    public synchronized int consume() throws InterruptedException {
        while (queue.isEmpty()) {
            System.out.println("큐가 비었음, 소비자 대기");
            wait(); // 락을 놓고 대기
        }
        int item = queue.poll();
        System.out.println("소비: " + item + " (큐 크기: " + queue.size() + ")");
        notifyAll(); // 대기 중인 생산자 깨우기
        return item;
    }
}

Thread daemon = new Thread(() -> {
    while (true) {
        System.out.println("백그라운드 작업 실행 중...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            break;
        }
    }
});

daemon.setDaemon(true); // 반드시 start() 전에 설정
daemon.start();

Thread.sleep(3000);
System.out.println("main 종료 → 데몬도 자동 종료");