---
id: java-threads
title: "Java Threads"
category: "Programming_Language"
status: "draft"
verification_status: "conceptual"
canonical_id: ""
aliases: ["자바 스레드"]
duplicate_of: ""
source_trust_level: "B"
confidence_score: 0.88
created_at: 2026-07-04
updated_at: 2026-07-04
review_reason: ""
merge_history: []
tags: ["java", "programming", "w3schools", "threads", "concurrency"]
raw_sources: ["https://www.w3schools.com/java/java_threads.asp"]
applied_in: []
github_commit: ""
---

# [[Java Threads]]

## 🎯 한 줄 통찰 (One-line insight)
Extending `Thread` blocks you from extending any other class (Java has single inheritance), so implementing `Runnable` is the more flexible option specifically because it lets you write `class MyClass extends OtherClass implements Runnable` — the choice between the two thread-creation methods is really a choice about whether you need that inheritance slot for something else. [S1]

## 🧠 핵심 개념 (Core concepts)
- **Two ways to create a thread** — extend `Thread` and override `run()`, or implement `Runnable` and pass an instance to `new Thread(obj)`. [S1]
- **`.start()`** — begins running the thread (not calling `run()` directly). [S1]
- **Extend vs. implement trade-off** — extending Thread blocks further inheritance; implementing Runnable allows extending another class too. [S1]
- **Concurrency problems** — since threads run in unpredictable order relative to the main program, shared variables can produce unpredictable values. [S1]
- **`isAlive()`** — checks if a thread is still running; used to wait for a thread to finish before touching shared state. [S1]

## 📖 세부 내용 (Details)
- Extend Thread: `public class Main extends Thread { public void run() { System.out.println("This code is running in a thread"); } } ... Main thread = new Main(); thread.start();`. [S1]
- Implement Runnable: `public class Main implements Runnable { public void run() {...} } ... Main obj = new Main(); Thread thread = new Thread(obj); thread.start();`. [S1]
- Concurrency problem example: `public static int amount = 0; ... thread.start(); System.out.println(amount); amount++; ... // run() { amount++; } — order/value unpredictable`. [S1]
- Safe wait via isAlive(): `while(thread.isAlive()) { System.out.println("Waiting..."); } System.out.println("Main: " + amount);`. [S1]

## ⚖️ 모순 및 업데이트 (Contradictions & updates)
- **동시성 문제의 근본 원인**: 스레드와 메인 프로그램이 같은 변수를 동시에 읽고 쓰면 값이 예측 불가능해진다는 점이 명시되고, isAlive()로 대기하는 것이 해결책으로 제시됨. [S1]

## 🛠️ 적용 사례 (Applied in summary)
현재 발견된 실제 적용 사례가 없습니다 — isAlive()로 스레드 완료를 기다린 후 공유 변수에 접근하는 패턴이 동시성 문제 회피의 실전 사례다. [S1]

## 💻 코드 패턴 (Code patterns)
Waiting for a thread with isAlive() to avoid concurrency issues (Java):
```java
public class Main extends Thread {
    public static int amount = 0;
    public static void main(String[] args) {
        Main thread = new Main();
        thread.start();
        while (thread.isAlive()) {
            System.out.println("Waiting...");
        }
        System.out.println("Main: " + amount);
    }
    public void run() { amount++; }
}
```

## ✅ 검증 상태 및 신뢰도
- **상태:** draft
- **검증 단계:** conceptual
- **출처 신뢰도:** B (W3Schools — widely used educational reference, not a primary standards body)
- **신뢰 점수:** 0.88
- **중복 검사 결과:** 신규 생성 (New discovery)

## 🔗 지식 그래프 (Knowledge Graph)
- **상위/루트:** [[Java Tutorial]]
- **관련 개념:** [[Java Interface]], [[Java Inheritance]], [[Java Lambda]]
- **참조 맥락:** 병렬 실행과 동시성 문제 — 람다 표현식(Lambda) 챕터로 이어짐.

## 📚 출처 (Sources)
- [S1] W3Schools — Java Threads — https://www.w3schools.com/java/java_threads.asp

## 📝 변경 이력 (Change history)
- 2026-07-04: Initial draft synthesized from the W3Schools "Java Threads" page (Astra wiki-curation, P-Reinforce v3.1 format).