# 자바 동시성(Concurrency) API 정리 및 쉬운 설명

자바의 동시성(Concurrency) API는 **멀티스레딩을 효율적으로 관리하고 안전하게 실행할 수 있도록 지원하는 기능**을 제공한다.  
즉, **여러 작업을 동시에 실행하여 프로그램 성능을 향상**시킬 수 있다.

---

## 1. 주요 클래스 및 메서드 정리  

### (1) `Thread` 클래스 (기본 스레드 실행)

| 메서드 | 설명 |
|--------|------------------------------|
| `start()` | 새로운 스레드를 실행 |
| `run()` | 실행할 코드 정의 (직접 호출하면 동작하지 않음) |
| `sleep(ms)` | 지정된 시간(ms) 동안 스레드 일시 정지 |
| `join()` | 현재 스레드가 종료될 때까지 다른 스레드 대기 |
| `interrupt()` | 실행 중인 스레드를 인터럽트 (깨우기) |
| `isAlive()` | 스레드가 실행 중인지 확인 |

**사용 예시:**  
```java
class MyThread extends Thread {
    public void run() {
        System.out.println("스레드 실행 중!");
    }
}

MyThread t = new MyThread();
t.start();  // 스레드 실행
```

---

### (2) `Runnable` 인터페이스 (스레드 실행)

| 메서드 | 설명 |
|--------|------------------------------|
| `run()` | 실행할 코드 정의 |

**사용 예시:**  
```java
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Runnable 스레드 실행!");
    }
}

Thread t = new Thread(new MyRunnable());
t.start();
```
→ `Thread` 클래스를 직접 상속하지 않고 `Runnable`을 구현하여 사용.

---

### (3) `ExecutorService` (스레드 풀)

| 메서드 | 설명 |
|--------|------------------------------|
| `submit(Runnable)` | 스레드를 실행 (결과 없음) |
| `submit(Callable<T>)` | 스레드를 실행하고 결과 반환 |
| `shutdown()` | 스레드 풀 종료 (기존 작업 수행 후 종료) |
| `shutdownNow()` | 즉시 모든 작업 중단 |

**사용 예시:**  
```java
ExecutorService executor = Executors.newFixedThreadPool(2);

executor.submit(() -> System.out.println("스레드 풀에서 실행"));
executor.shutdown();
```
→ `Executors.newFixedThreadPool(2)`를 사용해 2개의 스레드를 관리.

---

### (4) `Callable` & `Future` (결과 반환이 필요한 작업)

| 메서드 | 설명 |
|--------|------------------------------|
| `call()` | 실행할 코드 정의, 결과 반환 |
| `get()` | `Future`에서 결과 가져오기 (블로킹) |
| `isDone()` | 작업 완료 여부 확인 |

**사용 예시:**  
```java
Callable<Integer> task = () -> {
    Thread.sleep(1000);
    return 10;
};

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<Integer> future = executor.submit(task);

System.out.println(future.get()); // 결과 가져오기
executor.shutdown();
```
→ `Callable`을 사용하면 **스레드 실행 후 결과 값을 반환**할 수 있음.

---

### (5) `ReentrantLock` (락을 이용한 동기화)

| 메서드 | 설명 |
|--------|------------------------------|
| `lock()` | 락 획득 |
| `unlock()` | 락 해제 |
| `tryLock()` | 락을 시도하고 성공하면 `true` 반환 |

**사용 예시:**  
```java
ReentrantLock lock = new ReentrantLock();

lock.lock();
try {
    System.out.println("임계영역 실행");
} finally {
    lock.unlock();
}
```
→ `synchronized` 키워드 대신 `ReentrantLock`을 사용하여 더 정교한 동기화 가능.

---

### (6) `Semaphore` (동시 실행 제한)

| 메서드 | 설명 |
|--------|------------------------------|
| `acquire()` | 리소스 사용 요청 (없으면 대기) |
| `release()` | 사용한 리소스 반환 |

**사용 예시:**  
```java
Semaphore semaphore = new Semaphore(2);

semaphore.acquire(); // 사용 가능하면 진행, 아니면 대기
System.out.println("리소스 사용 중");
semaphore.release();
```
→ 한 번에 2개의 스레드만 특정 코드 실행 가능.

---

### (7) `CountDownLatch` (스레드가 모두 끝날 때까지 대기)

| 메서드 | 설명 |
|--------|------------------------------|
| `await()` | 모든 스레드가 완료될 때까지 대기 |
| `countDown()` | 하나의 작업 완료 처리 |

**사용 예시:**  
```java
CountDownLatch latch = new CountDownLatch(3);

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        System.out.println("작업 완료");
        latch.countDown();
    }).start();
}

latch.await();
System.out.println("모든 작업 완료");
```
→ 모든 작업(`countDown()` 3회)이 끝나야 `await()`이 풀림.

---

### (8) `CyclicBarrier` (스레드가 모두 도달할 때까지 대기)

| 메서드 | 설명 |
|--------|------------------------------|
| `await()` | 지정된 개수의 스레드가 모일 때까지 대기 |

**사용 예시:**  
```java
CyclicBarrier barrier = new CyclicBarrier(3, () -> {
    System.out.println("모든 스레드 도착!");
});

for (int i = 0; i < 3; i++) {
    new Thread(() -> {
        System.out.println("스레드 실행 중");
        barrier.await();
    }).start();
}
```
→ `CyclicBarrier`는 정해진 개수의 스레드가 모두 도착할 때까지 기다림.

---

## 2. 자바 동시성 쉽게 설명하기  

자바에서 동시성을 다룰 때 중요한 개념은 **멀티스레딩과 스레드 동기화**다.  
즉, 여러 개의 스레드가 **같은 자원을 동시에 접근하면 충돌이 발생**할 수 있으므로, 이를 적절히 제어해야 한다.

### 1️⃣ **기본적인 멀티스레드**
- `Thread` 또는 `Runnable`을 사용해 실행  
- `start()`로 실행, `join()`으로 대기  

### 2️⃣ **스레드 풀 사용 (`ExecutorService`)**
- 직접 스레드를 생성하면 관리가 어렵기 때문에, **스레드 풀을 사용하여 성능 최적화**  
- `submit()`으로 작업을 실행하고, `shutdown()`으로 종료  

### 3️⃣ **결과를 받아야 한다면? (`Callable` & `Future`)**
- `Callable`을 사용하면 작업이 끝난 후 결과 값을 반환 가능  
- `future.get()`을 호출하면 결과를 가져올 수 있음  

### 4️⃣ **공유 자원 충돌 방지 (`ReentrantLock`, `synchronized`)**
- `synchronized` 키워드는 단순하지만 유연성이 낮음  
- `ReentrantLock`은 더 정교한 동기화 제공  

### 5️⃣ **특정 조건을 만족할 때 실행 (`CountDownLatch`, `CyclicBarrier`)**
- `CountDownLatch` → 여러 개의 스레드가 끝날 때까지 대기  
- `CyclicBarrier` → 여러 스레드가 동시에 도달해야 실행  

---

## 3. 정리  

✅ 멀티스레딩을 쉽게 하려면? → `ExecutorService`  
✅ 스레드 실행 결과를 받아야 한다면? → `Callable`, `Future`  
✅ 여러 스레드가 동시에 공유 자원을 사용하면? → `ReentrantLock`, `synchronized`  
✅ 여러 작업이 끝난 후 실행되게 하려면? → `CountDownLatch`, `CyclicBarrier`  

즉, **자바 동시성 API를 적절히 활용하면 멀티스레딩을 효율적으로 관리할 수 있다!**