Java 멀티스레드와 동시성, 실무에서 꼭 알아야 할 핵심

public class MyThread extends Thread {
    private String threadName;
    
    public MyThread(String name) {
        this.threadName = name;
    }
    
    public void run() {
        System.out.println(threadName + " 시작!");
        try {
            // 실제 작업 시뮬레이션
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(threadName + " 완료!");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t1 = new MyThread("작업1");
        MyThread t2 = new MyThread("작업2");
        
        t1.start(); // run()이 아닌 start()로 실행!
        t2.start(); // 동시에 실행된다
    }
}

public class MyRunnable implements Runnable {
    private final String taskName;
    
    public MyRunnable(String taskName) {
        this.taskName = taskName;
    }
    
    public void run() {
        System.out.println(taskName + " 시작 - " + Thread.currentThread().getName());
        // 작업 수행
        System.out.println(taskName + " 완료!");
    }
}

// 사용법 1: Thread 생성자에 전달
Thread t = new Thread(new MyRunnable("DB 조회"));
t.start();

// 사용법 2: 람다 표현식 활용 (Java 8+)
Thread t2 = new Thread(() -> {
    System.out.println("람다로 간단하게!");
});
t2.start();

public class Counter {
    private int count = 0;
    
    // 메서드 전체 동기화
    public synchronized void increment() {
        count++;
    }
    
    // 동기화 블록 사용 (더 세밀한 제어)
    public void incrementWithBlock() {
        // 다른 작업들...
        synchronized(this) {
            count++;
        }
        // 다른 작업들...
    }
    
    public int getCount() {
        return count;
    }
}

// 동시성 문제 예시
public class ConcurrencyProblem {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        
        // 1000개의 스레드가 각각 1000번씩 증가
        Thread[] threads = new Thread[1000];
        for (int i = 0; i < 1000; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();
                }
            });
            threads[i].start();
        }
        
        // 모든 스레드가 끝날 때까지 대기
        for (Thread t : threads) {
            t.join();
        }
        
        System.out.println("최종 카운트: " + counter.getCount());
        // synchronized가 없다면 1,000,000이 아닌 값이 나올 수 있다!
    }
}

// 고정 크기 스레드풀
ExecutorService executor = Executors.newFixedThreadPool(3);

// 여러 작업 제출
for (int i = 0; i < 10; i++) {
    final int taskId = i;
    executor.submit(() -> {
        System.out.println("작업 " + taskId + " 시작 - " + Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        System.out.println("작업 " + taskId + " 완료!");
    });
}

// 새로운 작업 제출 중단
executor.shutdown();

// 모든 작업이 완료될 때까지 대기 (최대 1분)
try {
    if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
        executor.shutdownNow(); // 강제 종료
    }
} catch (InterruptedException e) {
    executor.shutdownNow();
}

// 1. 고정 크기 스레드풀 (가장 많이 사용)
ExecutorService fixedPool = Executors.newFixedThreadPool(5);

// 2. 캐시 스레드풀 (필요에 따라 스레드 생성/제거)
ExecutorService cachedPool = Executors.newCachedThreadPool();

// 3. 단일 스레드 (작업 순서 보장)
ExecutorService singleThread = Executors.newSingleThreadExecutor();

// 4. 스케줄 실행 (주기적 작업)
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(2);
scheduledPool.scheduleAtFixedRate(() -> {
    System.out.println("5초마다 실행!");
}, 0, 5, TimeUnit.SECONDS);

// 1. ConcurrentHashMap - 읽기/쓰기 동시 처리 최적화
Map<String, String> map = new ConcurrentHashMap<>();
map.put("key", "value");

// 동시에 여러 스레드가 접근해도 안전
map.compute("counter", (k, v) -> v == null ? "1" : String.valueOf(Integer.parseInt(v) + 1));

// 2. CopyOnWriteArrayList - 읽기가 많고 쓰기가 적을 때
List<String> list = new CopyOnWriteArrayList<>();
list.add("안전한 리스트");

// 3. BlockingQueue - 생산자-소비자 패턴
BlockingQueue<String> queue = new LinkedBlockingQueue<>();

// 생산자
new Thread(() -> {
    try {
        queue.put("작업1");
        queue.put("작업2");
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

// 소비자
new Thread(() -> {
    try {
        while (true) {
            String task = queue.take(); // 큐가 비어있으면 대기
            System.out.println("처리: " + task);
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
}).start();

public class DeadlockExample {
    private final Object lock1 = new Object();
    private final Object lock2 = new Object();
    
    public void method1() {
        synchronized(lock1) {
            System.out.println("Lock1 획득");
            synchronized(lock2) {
                System.out.println("Lock2 획득");
            }
        }
    }
    
    public void method2() {
        synchronized(lock2) {  // 순서가 반대!
            System.out.println("Lock2 획득");
            synchronized(lock1) {
                System.out.println("Lock1 획득");
            }
        }
    }
}

public class VolatileExample {
    private volatile boolean running = true;
    
    public void stop() {
        running = false; // 다른 스레드에서도 즉시 반영
    }
    
    public void doWork() {
        while (running) {
            // 작업 수행
        }
    }
}

public class UserContext {
    private static ThreadLocal<String> userHolder = new ThreadLocal<>();
    
    public static void setUser(String user) {
        userHolder.set(user);
    }
    
    public static String getUser() {
        return userHolder.get();
    }
    
    public static void clear() {
        userHolder.remove(); // 메모리 누수 방지!
    }
}