잡학다식 개발일지

자원 관리

1. 자원을 관리한다는 것은?

• 자원(Resource):
  • 프로그램이 실행되는 동안 사용하는 CPU, 메모리, 파일 핸들, 네트워크 소켓 등을 말함.
  • 제한된 자원을 효율적으로 사용해야 비용 절감과 성능 최적화 가능.
• 자원 관리의 중요성:
  • 자원의 불필요한 낭비를 줄이고, 프로그램의 성능과 안정성을 보장.
  • 자원 누수(Resource Leak)를 방지하여 시스템의 안정성을 유지.

2. 싱글턴 패턴 (Singleton Pattern)

• 설명:
  • 디자인 패턴의 하나로, 클래스의 단 하나의 인스턴스만 생성되도록 보장.
  • 모든 클라이언트가 이 인스턴스를 공유하여 자원을 절약.
  • 주로 전역 상태 관리, 공통된 작업 수행에 사용.
• 싱글턴 패턴의 장점:
  • 메모리 효율성: 인스턴스를 하나만 생성하여 메모리 낭비 방지.
  • 글로벌 접근성: 어디서든 같은 인스턴스를 참조 가능.
• 싱글턴 패턴의 주의점:
  • 상태 관리: 싱글턴 객체가 상태를 가진다면, 다중 쓰레드 환경에서 데이터 무결성을 보장해야 함.
  • 의존성 주입 사용 권장: 테스트와 확장성을 고려해, 직접 싱글턴을 참조하기보다 DI(Dependency Injection)를 사용하는 것이 좋음.
• 싱글턴 패턴 사용 예시:
  • 데이터베이스 연결 관리: 하나의 연결 객체로 다수의 요청 처리.
  • 로깅: 애플리케이션 전역에서 동일한 로깅 객체 사용.
  • 설정 관리: 환경 설정 값을 하나의 객체로 관리.
• Kotlin의 싱글턴 구현:
• object Singleton { fun showMessage() { println("Hello from Singleton!") } } fun main() { Singleton.showMessage() }

3. Companion Object

• 설명:
  • Kotlin에서 클래스 내부에 포함된 특별한 객체.
  • 클래스의 인스턴스 없이 멤버에 접근 가능.
  • 자바의 static 키워드와 비슷한 역할.
• 사용 목적:
  • 클래스 레벨에서 공통적으로 사용되는 함수나 변수 관리.
  • 팩토리 메서드 구현 등.
• 예제:
• data class UserDto(val username: String, val password: String) { companion object { fun encodePassword(password: String): String { return password.reversed() // 단순한 비밀번호 암호화 } } } fun main() { val encodedPassword = UserDto.encodePassword("12345") println("Encoded Password: $encodedPassword") }

4. 지연 초기화 (Lazy Initialization)

• 설명:
  • 필요한 시점에 객체를 초기화하여 메모리와 성능을 최적화하는 기법.
  • Kotlin에서는 lazy 키워드를 사용하여 구현.
• 장점:
  • 성능 개선: 객체가 실제로 필요할 때만 초기화하여 초기 로딩 속도 개선.
  • 메모리 효율성: 불필요한 메모리 사용 방지.
• 예제:
• class Image(val imageFile: String) { val thumbnail: String by lazy { println("Generating thumbnail...") "Thumbnail for $imageFile" } } fun main() { val image = Image("photo.jpg") println("Image loaded") println(image.thumbnail) // 이 시점에서 thumbnail 초기화 }

5. 인라인 함수 (Inline Function)

• 설명:
  • 함수 호출 시, 함수 본문을 호출 지점에 직접 삽입하는 방식.
  • 람다나 고차 함수에서 객체 생성을 피하기 위해 메모리 효율적으로 사용.
• 장점:
  • 함수 호출 오버헤드 감소.
  • 고차 함수에서 불필요한 객체 생성 제거.
• 단점:
  • 함수 크기가 클 경우, 인라인 사용 시 컴파일된 바이트코드가 커져 프로그램 크기 증가.
• 예제:
• inline fun compute(a: Int, action: () -> Unit): Int { action() return a * 2 } fun main() { val result = compute(10) { println("Action executed!") } println("Result: $result") }

6. 추가 학습이 필요한 주제

1. 자원 관리 기법:
   • try-with-resources(Java)나 use(Kotlin) 같은 자원 자동 해제 기법.
   • 파일, 네트워크 소켓, 데이터베이스 연결의 효율적인 관리.
2. 멀티쓰레드 환경에서 자원 관리:
   • 동기화(Synchronization)와 Lock, Semaphore 등의 동시성 제어 기법.
3. 객체 풀(Object Pool):
   • 자원을 효율적으로 재사용하기 위해 객체를 풀(Pool)로 관리하는 기법.
4. Dependency Injection (DI):
   • 싱글턴 객체와 함께 사용하면 코드의 확장성과 유지보수성을 높일 수 있음.
5. 성능 측정 도구:
   • 자원 사용량을 분석하고, 최적화 가능성을 식별하는 도구(Ex: Android Profiler, JConsole).

7. 정리

결론

자원 관리는 프로그램의 효율성과 안정성을 높이는 핵심 요소입니다. 싱글턴, Companion Object, Lazy Initialization, Inline Function과 같은 기술들은 자원의 효율적 사용뿐 아니라 코드의 가독성과 유지보수성을 높이는 데 기여합니다. 추가 학습을 통해 동시성과 멀티쓰레드 환경에서 자원을 관리하는 방법을 익히면 더욱 견고한 시스템을 구축할 수 있습니다. 

코루틴 (Coroutine)

1. 코루틴이란?

• 코루틴은 비동기 프로그래밍을 쉽게 구현할 수 있는 기술.
• Light-Weight Thread로 불리며, 쓰레드보다 가볍게 동시성을 구현 가능.
• 주요 목표:
  • 하드웨어 자원(CPU, 메모리) 효율적인 사용.
  • 안정적이고, 직관적인 비동기 코드 작성.
  • 운영체제의 깊은 이해 없이도 협동적 작업 처리 가능.

2. 코루틴의 주요 특징

1. 비동기 작업 최적화:
   • 대기 시간이 발생하는 작업(예: 네트워크 요청, 파일 입출력)을 효율적으로 처리.
2. 경량성:
   • 하나의 쓰레드에서 수백만 개의 코루틴 실행 가능.
   • 코루틴은 컨텍스트 스위칭(Context Switching) 없이 동일 쓰레드에서 작업을 교체 실행.
3. 동시성 프로그래밍:
   • 복잡한 동시성을 직관적이고 간결하게 구현.
4. Suspendable Functions (일시중단 함수):
   • suspend 키워드를 사용하여 일시적으로 작업을 중단하고, 다른 작업을 수행.
5. 사용자 정의 스위칭:
   • 작업 교체 시점을 개발자가 직접 지정 가능.

3. 코루틴 빌더

코루틴 실행을 시작하는 빌더를 사용하여 다양한 방식으로 작업 수행.

1. launch:
   • 결과값을 반환하지 않는 코루틴 빌더.
   • Job 객체를 반환하여 코루틴을 제어 가능.

   val job = GlobalScope.launch {
       delay(1000) // 1초 대기
       println("코루틴 작업 완료!")
   }
   

2. async:
   • 결과값을 반환하는 코루틴 빌더.
   • 반환값을 Deferred 객체로 받고, await()을 호출해 결과를 반환.

   val deferred = GlobalScope.async {
       delay(1000) // 1초 대기
       "코루틴 작업 완료!"
   }
   println(deferred.await()) // 결과 출력
   

3. runBlocking:
   • 현재 쓰레드를 차단하여 코루틴 작업이 완료될 때까지 대기.
   • 주로 테스트 코드나 코루틴을 호출하는 비코루틴 환경에서 사용.

   runBlocking {
       launch {
           delay(1000)
           println("비동기 작업 완료!")
       }
       println("runBlocking 종료")
   }
   

4. 코루틴 스코프

1. GlobalScope:
   • 앱 전체에 걸쳐 살아있는 코루틴을 생성.
   • 앱이 실행되는 동안 코루틴 유지.

   GlobalScope.launch {
       delay(1000)
       println("GlobalScope 코루틴")
   }
   

2. CoroutineScope:
   • 필요한 시점에 생성하고, 사용 후 정리 가능.
   • 자식 코루틴의 생명 주기를 관리.

   val scope = CoroutineScope(Dispatchers.Default)
   scope.launch {
       delay(1000)
       println("CoroutineScope 코루틴")
   }
   

5. 디스패처 (Dispatcher)

코루틴이 실행될 쓰레드를 결정.

1. Dispatchers.Main:
   • UI와 상호작용하거나 사용자 이벤트 처리에 적합.
   • Android 개발에서 많이 사용.
2. Dispatchers.IO:
   • 네트워크 통신, 파일 입출력 등 I/O 작업에 최적화.
3. Dispatchers.Default:
   • CPU 집약적인 작업(데이터 처리, 복잡한 계산 등)에 적합.
4. Dispatchers.Unconfined:
   • 제한되지 않은 디스패처. 실행 환경에 따라 동적으로 실행.

6. 쓰레드와 코루틴의 차이

7. 예시 코드

1) 간단한 코루틴 실행

fun main() = runBlocking {
    launch {
        delay(1000)
        println("첫 번째 코루틴")
    }
    println("메인 함수")
}

2) 여러 코루틴 실행

fun main() = runBlocking {
    val job1 = async {
        delay(2000)
        "작업 1 완료"
    }
    val job2 = async {
        delay(1000)
        "작업 2 완료"
    }
    println(job1.await())
    println(job2.await())
}

8. 추가 학습이 필요한 주제

1. 코루틴 컨텍스트와 스코프:
   • CoroutineScope와 SupervisorJob의 역할 및 사용 방법.
2. 에러 처리:
   • 코루틴 내 예외 처리 방법 (try-catch, supervisorScope).
3. 코루틴 채널 (Channels):
   • 코루틴 간 데이터를 주고받는 통신 방식.
4. Flow:
   • Kotlin의 비동기 데이터 스트림 처리 도구.
5. 테스트:
   • runBlockingTest와 같은 코루틴 기반 테스트 도구 활용.

9. 결론

코루틴은 효율적인 비동기 프로그래밍과 동시성 처리를 위한 강력한 도구입니다. Google에서 Android 개발에 적극 권장하며, 현대적인 비동기 처리를 위해 필수적인 기술로 자리 잡고 있습니다. 학습을 통해 코루틴의 다양한 사용법과 최적화 기법을 익히는 것이 중요합니다. 😊

비동기 프로그래밍

1. 비동기 프로그래밍이란?

• 비동기 프로그래밍(Asynchronous Programming):
  • 작업이 완료될 때까지 기다리지 않고, 다른 작업을 수행할 수 있도록 처리하는 방식.
  • **시간이 오래 걸리는 작업(예: 파일 다운로드, 네트워크 요청)**이 진행되는 동안 앱이나 프로그램이 멈추지 않고 다른 작업을 계속 실행.
• 동기적 프로그래밍과의 차이점:
  • **동기적 프로그래밍(Synchronous Programming)**은 작업을 순차적으로 실행하며, 이전 작업이 완료될 때까지 기다려야 다음 작업을 시작.
  • 반면, 비동기 프로그래밍은 작업의 완료 여부와 관계없이 다른 작업을 병렬적으로 실행.

2. 비동기 프로그래밍의 필요성

• 효율적인 자원 사용:
  • I/O 작업(네트워크, 파일 시스템 등)에서 작업 완료를 기다리지 않고, 유휴 상태인 CPU를 활용 가능.
• 사용자 경험 개선:
  • 긴 작업이 진행되는 동안 애플리케이션이 멈추거나 응답하지 않는 문제를 방지.
• 동시성 지원:
  • 여러 작업이 동시에 실행되도록 설계하여 멀티태스킹 구현 가능.

3. 동기와 비동기의 차이

4. 비동기 프로그래밍의 예시

예시 1: 동기 프로그래밍

// 동기 방식: 모든 작업이 순서대로 실행
System.out.println("1. 5GB 영상 다운로드 중...");
Thread.sleep(5000); // 5초 동안 대기
System.out.println("2. 메일 전송 중...");
Thread.sleep(2000); // 2초 동안 대기
System.out.println("3. 알림 전송 완료!");

• 출력:

  1. 5GB 영상 다운로드 중...
  2. 메일 전송 중...
  3. 알림 전송 완료!
  

• 동기 방식에서는 앞선 작업이 끝날 때까지 다음 작업이 대기.

예시 2: 비동기 프로그래밍

// 비동기 방식: 각 작업이 병렬적으로 실행
System.out.println("1. 5GB 영상 다운로드 요청!");
CompletableFuture.runAsync(() -> {
    try {
        Thread.sleep(5000); // 5초 동안 대기 (다운로드)
        System.out.println("2. 영상 다운로드 완료!");
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
});
System.out.println("3. 메일 전송 중...");
Thread.sleep(2000); // 2초 동안 대기
System.out.println("4. 알림 전송 완료!");

• 출력:

  1. 5GB 영상 다운로드 요청!
  3. 메일 전송 중...
  4. 알림 전송 완료!
  2. 영상 다운로드 완료!
  

• 작업이 병렬로 실행되어 응답성이 향상.

5. 비동기 프로그래밍을 활용한 생활 속 사례

1. 웹 브라우저:
   • 웹 페이지를 로드하는 동안 이미지나 추가 데이터를 백그라운드에서 다운로드.
2. 모바일 앱:
   • 사용자가 앱을 탐색하는 동안, 새로운 메시지나 알림을 비동기로 가져옴.
3. 게임:
   • 게임 플레이 중, 백그라운드에서 리소스 로드 또는 업데이트.
4. 파일 업로드:
   • 사용자가 다른 작업을 계속할 수 있도록 대용량 파일을 비동기적으로 업로드.

6. 비동기 프로그래밍의 장점과 단점

7. 비동기 프로그래밍 구현 방식

1. 콜백 (Callback):
   • 특정 작업 완료 후 실행할 동작을 미리 정의.
   • 단점: "콜백 지옥"으로 인해 코드 가독성이 떨어질 수 있음.
2. Promise/Future:
   • 작업 완료 후 반환값을 처리하는 객체.
   • 단점: 여러 Promise를 연결하면 복잡해질 수 있음.
3. Async/Await:
   • 비동기 작업을 동기 코드처럼 읽기 쉽게 작성.
   • 단점: 예외 처리를 적절히 구현해야 함.

8. 비동기 프로그래밍이 적합한 상황

• 네트워크 요청:
  • 외부 API 호출, 데이터베이스 쿼리 등.
• 대용량 작업 처리:
  • 파일 입출력, 대규모 데이터 처리.
• 사용자 인터페이스 응답성 개선:
  • UI 작업 중 애플리케이션 멈춤 방지.

결론

비동기 프로그래밍은 애플리케이션의 성능과 응답성을 높이는 데 매우 중요한 프로그래밍 기법입니다. 동기적 흐름에서 발생할 수 있는 병목 현상을 해결하고, 사용자가 더 나은 경험을 할 수 있도록 돕습니다. 하지만 구현의 복잡성이 증가할 수 있으므로, **상황에 맞는 패턴(콜백, Promise, Async/Await)**을 사용해 관리해야 합니다. 

쓰레드(Thread)

1. 쓰레드란?

• **쓰레드(Thread)**는 프로그램 내에서 작업을 실행하는 최소 실행 단위.
• 하나의 프로그램(프로세스)은 기본적으로 하나의 메인 쓰레드(fun main(0 메인함수)에서 실행되며, 이를 통해 모든 작업이 처리됨.
• 추가 쓰레드를 생성하면 여러 작업을 동시에 처리할 수 있어 **동시성(Concurrency)**을 구현할 수 있음.

2. 쓰레드의 기본 개념

1. 프로세스(Process):
   • 실행 중인 프로그램으로, 운영체제(OS)에서 메모리와 CPU를 할당받아 독립적으로 실행됨.
   • 각 프로세스는 독립된 메모리 공간(코드, 데이터, 힙, 스택)을 가짐.
2. 쓰레드(Thread):
   • 프로세스 내에서 실행되는 작은 작업 단위.
   • 스택 메모리를 독립적으로 사용하지만, 힙 메모리(공유 자원)는 다른 쓰레드와 공유.
3. 쓰레드의 메모리 구조:
   • 스택(Stack): 쓰레드마다 독립된 실행 컨텍스트를 저장.
   • 힙(Heap): 모든 쓰레드가 공유하는 메모리 공간.
   • 코드/데이터 영역: 프로그램의 실행 코드와 상수 저장.

3. 쓰레드의 특징

4. 쓰레드의 필요성

1. 동시성(Concurrency) 구현:
   • 하나의 작업을 여러 단위로 나누어 동시에 처리.
   • 예: UI 처리 중 파일 다운로드.
2. 대기 시간 최소화:
   • 시간이 오래 걸리는 작업(네트워크 요청, 파일 입출력 등) 동안 다른 작업을 중단 없이 실행.
3. 프로그램 효율성 향상:
   • 멀티코어 CPU에서 여러 쓰레드를 실행하면 자원을 효율적으로 활용 가능.

5. 쓰레드를 사용하는 주요 사례

1. 게임:
   • 캐릭터의 움직임, 효과음, 사용자 입력 처리를 동시에 수행.
2. 멀티미디어 애플리케이션:
   • 비디오 재생 중 오디오 출력과 자막 표시를 병렬로 실행.
3. 네트워크 서버:
   • 여러 클라이언트 요청을 동시에 처리.
4. 경쟁 환경:
   • 경마 프로그램처럼 여러 개체가 동시에 움직이고 결과를 경쟁.

6. 쓰레드의 구현

1) Kotlin에서 쓰레드 생성

fun main() {
    thread(start = true) {
        println("Thread 1: 실행 중")
    }

    thread(start = true) {
        println("Thread 2: 실행 중")
    }
}

2) 쓰레드 경쟁 예제

fun main() {
    thread(start = true) {
        for (i in 1..10) {
            println("Thread 1: $i")
            Thread.sleep(500) // 0.5초 대기
        }
    }

    thread(start = true) {
        for (i in 50..60) {
            println("Thread 2: $i")
            Thread.sleep(500) // 0.5초 대기
        }
    }
}

3) 쓰레드 동기화 문제 해결

• 여러 쓰레드가 공유 자원을 동시에 접근할 경우, 데이터 충돌 문제 발생 가능.
• 해결 방법: synchronized 키워드로 동기화 처리.

val lock = Any()
var sharedResource = 0

fun main() {
    thread(start = true) {
        synchronized(lock) {
            for (i in 1..5) {
                sharedResource++
                println("Thread 1: $sharedResource")
            }
        }
    }

    thread(start = true) {
        synchronized(lock) {
            for (i in 1..5) {
                sharedResource++
                println("Thread 2: $sharedResource")
            }
        }
    }
}

7. 쓰레드의 장단점

8. 추가 학습이 필요한 주제

1. 코루틴 (Coroutine):
   • 쓰레드보다 가볍고 효율적인 비동기 프로그래밍 방식.
   • Kotlin의 대표적인 비동기 처리 도구.
2. 동기화(Synchronization):
   • 공유 자원 접근 시 발생하는 문제를 해결하기 위한 기술.
   • Mutex, Semaphore, Volatile 등.
3. 컨텍스트 스위칭(Context Switching):
   • 쓰레드 간 전환 시 발생하는 비용과 효율성 최적화 방법.
4. 멀티쓰레드 디버깅:
   • 복잡한 쓰레드 환경에서의 오류 해결 방법.
5. Reactive Programming:
   • 비동기 데이터를 처리하는 프로그래밍 패러다임. (Ex: RxJava, Project Reactor)

9. 결론

쓰레드는 동시성과 병렬성을 구현하기 위한 강력한 도구입니다. 하지만 쓰레드를 잘못 설계하면 데이터 충돌, 데드락 등 복잡한 문제가 발생할 수 있습니다. 쓰레드의 한계를 보완하기 위해 코루틴 같은 최신 기술도 함께 학습하면 더욱 효율적인 프로그래밍이 가능합니다. 

프로세스

📌 실행 중인 프로그램을 의미합니다. 프로그램을 실행하면 OS로부터 실행에 필요한 자원(메모리)를 할당받아 프로세스가 됩니다. 프로세스는 운영체제의 주요 관리 단위이며, 독립적으로 실행됩니다.

1. 프로세스의 구성 요소

• 코드 영역(Code Segment) 
  실행할 프로그램의 명령어가 저장된 영역. CPU는 여기서 명령을 읽어 실행합니다.
• 데이터 영역(Data Segment)
  전역 변수와 정적 변수가 저장되는 영역.
• 힙 영역(Heap Segment)
  실행 중 동적으로 할당된 메모리가 저장되는 영역. 예: malloc()이나 new를 통한 메모리 할당. (객체, 변수등 저장)
• 스택 영역(Stack Segment)ㄴ
  함수 호출 시 사용되는 메모리 영역으로, 지역 변수와 함수 호출 정보를 저장.(호출에 필요한 참조 정보 저장)

• 간단하게는, 자원 + 쓰레드 단수~복수로 이루어져 있다. 공장(프로세스)에서 월급(자원)받아 일하는 일꾼(쓰레드)

2. 프로세스의 상태

프로세스는 실행 중 다양한 상태를 가집니다. 대표적인 상태는 다음과 같습니다:

• New (생성): 프로세스가 생성되고 초기화 중인 상태.
• Ready (준비): 실행되기를 기다리는 상태. CPU가 사용 가능할 때 실행됨.
• Running (실행): CPU에서 명령어가 실행 중인 상태.
• Waiting (대기): I/O 작업 같은 이벤트를 기다리는 상태.
• Terminated (종료): 실행을 완료한 상태.

3. 프로세스와 쓰레드

• 프로세스는 프로그램 실행의 독립적인 단위이며, 다른 프로세스와 메모리 공간을 공유하지 않습니다.
• 쓰레드는 프로세스 내에서 실행되는 작업의 흐름으로, 같은 프로세스의 메모리 공간을 공유합니다. (멀티쓰레드를 사용하는 이유는 효율적인 자원 사용과 빠른 동작을 위함입니다.)
• 기본적으로 쓰레드는 같은 프로세스의 메모리 공간을 공유하지만, 스택은 예외적으로 스레드마다 독립적인 스택을 가집니다. (매개변수, 리턴 주소, 지역 변수 등)

4. 프로세스 간 통신 (IPC: Inter-Process Communication)

프로세스는 독립적이지만, 특정 경우 데이터를 공유하거나 협력하기 위해 통신합니다. 주요 방법은 다음과 같습니다:

• 파이프(Pipe): 한쪽에서 쓰면 다른 쪽에서 읽는 방식.
• 메시지 큐(Message Queue): 메시지를 보내고 받는 방식.
• 공유 메모리(Shared Memory): 프로세스들이 특정 메모리 공간을 공유.
• 소켓(Socket): 네트워크 통신 기반의 프로세스 간 통신.

5. 프로세스 관리

운영체제는 프로세스를 다음과 같은 방식으로 관리합니다:

• 프로세스 생성: fork() (UNIX 계열) 또는 CreateProcess() (Windows)를 통해 생성.
• 스케줄링: CPU 시간을 효율적으로 분배. 대표적인 알고리즘은 Round Robin, FIFO, Priority Scheduling 등이 있습니다.
• 프로세스 종료: 실행이 끝나거나 강제로 종료(kill, terminate).

6. 프로세스의 예시

1. 사용자가 웹 브라우저를 실행 -> 브라우저는 새로운 프로세스 생성.
2. 브라우저가 탭마다 새로운 프로세스를 생성 -> 충돌 방지 및 독립성 보장.

쓰레드

📌 프로세스 내에서 실행되는 작업의 단위입니다. 하나의 프로세스는 여러 쓰레드를 가질 수 있으며, 이를 통해 병렬 작업(멀티쓰레딩)을 수행할 수 있습니다. 쓰레드는 프로세스의 자원을 공유하면서 독립적인 실행 흐름을 가집니다.

1. 쓰레드의 특징

1. 독립적인 실행 흐름
   • 쓰레드는 프로세스 내에서 별도의 실행 흐름을 가집니다.
   • 운영체제는 각 쓰레드에 CPU 시간을 할당하여 동시에 실행되는 것처럼 보이게 만듭니다(멀티태스킹).
2. 메모리 공간 공유
   • 같은 프로세스 내 쓰레드는 코드, 데이터, 힙 영역을 공유합니다.
   • 하지만 각 쓰레드는 자신만의 스택(Stack) 공간을 가집니다.
3. 경량 프로세스
   • 쓰레드는 프로세스에 비해 생성, 스위칭, 종료가 더 빠르고 자원 소모가 적습니다.

2. 쓰레드의 메모리 구조

1. 공유되는 영역
   • 코드 영역: 실행할 명령어 공유.
   • 데이터 영역: 전역 변수 및 정적 변수 공유.
   • 힙 영역: 동적으로 할당된 객체 공유.
2. 독립적인 영역
   • 스택 영역: 각 쓰레드마다 고유한 스택을 가집니다. 함수 호출 시 매개변수, 지역 변수, 리턴 주소 등이 저장됩니다.

3. 쓰레드의 동작 방식

• 쓰레드는 운영체제의 스케줄러에 의해 실행 상태가 관리됩니다.
• 생성 → 실행 → 대기 → 종료 상태를 거칩니다.
• 같은 프로세스 내의 쓰레드는 자원을 공유하므로, 동시에 작업을 수행할 수 있지만 동기화가 필요할 때도 있습니다.

+ 다수의 쓰레드가 동시에 공유데이터에 접근하면 데이터가 훼손되는 문제가 생기기도 합니다. 이를 방지하기 위해 동기화라는 작업을 수행합니다. 

4. 멀티쓰레드의 장점과 단점

장점:

1. 병렬 처리: 여러 작업을 동시에 처리하여 성능 향상.
2. 자원 공유: 프로세스 자원을 공유하므로 효율적.
3. 빠른 생성과 종료: 새로운 프로세스를 생성하는 것보다 경량.

단점:

1. 동기화 문제: 자원 접근 시 충돌을 방지하기 위해 동기화가 필요 (예: 뮤텍스, 세마포어).
2. 디버깅의 어려움: 병렬 처리로 인해 버그를 재현하거나 추적하기 어려움.
3. 컨텍스트 스위칭 비용: 스케줄러가 쓰레드를 전환할 때 약간의 오버헤드 발생.

5. 쓰레드 생성 방법

1) Java에서의 쓰레드 생성

• Thread 클래스 상속
• Runnable 인터페이스 구현

위의 2개의 방식이 일반적이지만, Thread의 경우 엄연히 클래스임으로 Thread를 사용할 경우 다른 class를 상속할 수 없습니다.(자바는 다중 상속이 안되지만 C의 경우 가능합니다.) 그래서 일반적으로는 Runnable 인터페이스로 구현합니다.

// Runnable 인터페이스 구현
class MyRunnable implements Runnable {
    public void run() {
        System.out.println("Thread is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        Thread t = new Thread(new MyRunnable());
        t.start();
    }
}

// Thread 클래스 상속
class MyThread extends Thread {
    public void run() {
        System.out.println("Thread is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread t = new MyThread();
        t.start();
    }
}

6. 쓰레드와 동기화

• 멀티쓰레드 환경에서는 여러 쓰레드가 동시에 공유 자원에 접근할 때 문제가 발생할 수 있습니다.
• 동기화 기법:
  • 뮤텍스(Mutex): 한 번에 하나의 쓰레드만 자원 접근 허용.
  • 세마포어(Semaphore): 지정된 수의 쓰레드만 자원 접근 허용.
  • 모니터(Monitor): Java의 synchronized 키워드 사용.

7. 쓰레드와 프로세스의 차이

main 쓰레드

📌 프로그래밍에서 항상 사용하는 main메서드의 작업을 수행하는 쓰레드를 의미합니다.

• 아무리 짧은 프로그램이라도 일꾼이 있어야 프로그램이 돌아가는 만큼, 쓰레드가 존재합니다.