[java] Thread 실습 (운영체제🦖 강의-Chpater4. Thread & Cocurrency)

1. Thread란?

운영체제에서 하나의 프로세스(process)는 여러 개의 쓰레드(thread)를 가질 수 있다. 쓰레드는 프로세스 내에서 실행 흐름을 의미하며, 프로세스의 자원을 공유하면서도 독립적인 실행 흐름을 가진다. 즉, 하나의 프로세스 내에서 여러 작업을 동시에 수행할 수 있도록 도와준다.

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

• 프로세스는 실행 중인 프로그램의 인스턴스로, 독립적인 메모리 공간(Code, Data, Heap, Stack 등)을 가진다.
• 쓰레드는 프로세스 내에서 실행되는 작은 단위로, 같은 프로세스 내의 다른 쓰레드들과 Code, Data, Heap, File 등의 자원을 공유하지만, 프로그램 카운터(PC), 레지스터, 스택(Stack)은 개별적으로 관리된다.
• 따라서 프로세스 간 통신(IPC: Inter-Process Communication)은 상대적으로 비용이 많이 들지만, 쓰레드 간 통신은 공유 메모리를 활용하여 훨씬 효율적으로 수행될 수 있다.

1.2. CPU 스케줄링 단위

CPU를 점유하는 단위는 **프로세스 ID(pid)가 아니라 쓰레드 ID(tid)**이다. 즉, 실제로 CPU를 점유하고 실행하는 것은 프로세스가 아니라 쓰레드이며, 각 쓰레드는 독립적인 프로그램 카운터(PC), 레지스터, 스택을 가진다.

 

2. 멀티쓰레딩(Multithreading)

멀티쓰레딩은 하나의 프로세스 내에서 여러 개의 쓰레드를 생성하여 병렬로 실행하는 기술이다. 이를 통해 프로그램의 성능을 향상시킬 수 있다.

2.1. 멀티쓰레딩의 장점

1. 응답성(Responsiveness):
   • 사용자의 입력을 빠르게 처리할 수 있음
   • 예를 들어, GUI 프로그램에서 UI 쓰레드가 별도로 동작하면, 시간이 오래 걸리는 연산 중에도 UI가 멈추지 않고 반응할 수 있음
2. 자원 공유(Resource Sharing):
   • 프로세스 내에서 Code, Data, Heap 등을 공유하여 쓰레드 간 데이터 교환이 용이함
   • 별도의 공유 메모리를 만들 필요 없이 간단하게 데이터를 주고받을 수 있음
3. 경제성(Economy):
   • 새로운 프로세스를 생성하는 것보다 새로운 쓰레드를 생성하는 것이 비용이 적게 듦
   • 컨텍스트 스위칭(Context Switching)도 프로세스 간보다 쓰레드 간에서 더 빠름
4. 병렬성(Scalability):
   • 멀티코어 시스템에서 쓰레드를 활용하면 여러 작업을 동시에 실행하여 성능을 향상시킬 수 있음
   • CPU 코어가 많을수록 병렬 실행 효과가 더욱 극대화됨

2.2. 예제: 클라이언트-서버 모델에서의 멀티쓰레딩

예를 들어, 클라이언트-서버 시스템에서 클라이언트가 서버에 요청을 보낼 때, 서버는 각 요청을 개별 쓰레드로 처리할 수 있다. 이를 통해 하나의 요청을 처리하는 동안에도 다른 요청을 계속 받을 수 있으므로 서버의 응답성이 향상된다.

3. Java에서의 쓰레드 생성 방법: (1)Thread 클래스 상속

Java는 멀티쓰레딩을 기본적으로 지원하며, 다음과 같은 방식으로 쓰레드를 만들 수 있다.

다음은 Thread 클래스를 상속하여 쓰레드를 생성하고 실행하는 예제이다.

3.1. 코드 설명

package ch04;

class MyThread1 extends Thread {
	public void run() {
		try {
			while (true) {
				System.out.println("Hello, Thread!");
				Thread.sleep(500);
			}
		}
		catch (InterruptedException ie) {
			System.out.println("I'm interrupted");
		}
	}
}

public class ThreadExample1 {
	
	public static final void main(String[] args) {
		MyThread1 thread = new MyThread1();
		thread.start();
		System.out.println("Hello, My Child");
	}
}

3.2. 코드 분석

1) MyThread1 클래스: 쓰레드 정의

class MyThread1 extends Thread {

 

• Thread 클래스를 상속받아 새로운 쓰레드를 정의한다.
• Thread 클래스를 상속하면 run() 메서드를 오버라이딩하여 쓰레드의 동작을 구현할 수 있다.

public void run() {
    try {
        while (true) {
            System.out.println("Hello, Thread!");
            Thread.sleep(500);
        }
    }
    catch (InterruptedException ie) {
        System.out.println("I'm interrupted");
    }
}

 

• run() 메서드는 쓰레드가 실행될 때 수행할 동작을 정의한다.
• while (true)를 사용하여 무한 루프를 돌면서 "Hello, Thread!"를 0.5초마다 출력한다.
• Thread.sleep(500);을 호출하면 쓰레드가 500ms 동안 대기하게 된다. 이걸 없애면 너무 빠르게 출력된다.
• InterruptedException은 쓰레드가 강제 종료될 때 발생하는 예외로, catch 블록에서 "I'm interrupted"을 출력하고 종료된다.

2) ThreadExample1 클래스: 쓰레드 실행

public class ThreadExample1 {
    public static final void main(String[] args) {

 

• main() 메서드는 Java 프로그램의 시작점이다.

MyThread1 thread = new MyThread1();

 

• MyThread1 클래스의 객체(쓰레드)를 생성한다.

thread.start();

 

• start() 메서드를 호출하면 새로운 쓰레드가 생성되고 run() 메서드가 실행된다.
• run() 메서드를 직접 호출하지 않고 start()를 호출해야 멀티쓰레딩이 동작한다.

System.out.println("Hello, My Child");

 

• 메인 쓰레드에서 "Hello, My Child"를 출력한다.
• 메인 쓰레드와 MyThread1 쓰레드는 동시에 실행되므로 출력 순서는 보장되지 않는다.

3.3. 프로그램 실행 결과

이 프로그램을 실행하면 다음과 같은 결과가 나온다.

Hello, My Child
Hello, Thread!
Hello, Thread!
Hello, Thread!
Hello, Thread!
...

 

• "Hello, My Child"는 메인 쓰레드에서 실행된다.
• "Hello, Thread!"는 MyThread1 쓰레드에서 0.5초마다 반복 출력된다.
• 메인 쓰레드와 MyThread1 쓰레드는 독립적으로 실행되므로 출력 순서는 변동될 수 있다.

3.4. 쓰레드의 실행 순서가 일정하지 않은 이유

• start()를 호출하면 운영체제가 CPU를 할당할 때까지 쓰레드는 실행되지 않는다.
• 따라서 "Hello, My Child"가 "Hello, Thread!"보다 먼저 출력될 수도 있고, 후에 출력될 수도 있다.
• 운영체제가 쓰레드의 실행 순서를 결정하므로 실행할 때마다 결과가 다를 수 있다.

3.5. 정리

✅ Thread 클래스를 상속하여 새로운 쓰레드를 만들었다. ✅ run() 메서드에서 반복적으로 "Hello, Thread!"를 출력했다. ✅ thread.start();를 호출하면 새로운 쓰레드가 실행된다. ✅ 메인 쓰레드와 새로운 쓰레드는 독립적으로 실행되므로 실행 결과가 일정하지 않다.

4. Java에서의 쓰레드 생성 방법: (2)Runnable  인터페이스 구현

Java에서는 Thread 클래스를 상속하는 것 외에도 Runnable 인터페이스를 구현하여 쓰레드를 생성할 수 있다. 이 방법은 다중 상속이 불가능한 Java의 특성상 더욱 유연하게 쓰레드를 활용할 수 있도록 해준다.

4.1. 코드 설명

package ch04;

class MyThread2 implements Runnable {
    public void run() {
        try {
            while (true) {
                System.out.println("Hello, Runnable!");
                Thread.sleep(500);
            }
        }
        catch (InterruptedException ie) {
            System.out.println("I'm interrupted");
        }
    }
}

public class ThreadExample2 {
    public static final void main(String[] args) {
        Thread thread = new Thread(new MyThread2());
        thread.start();
        System.out.println("Hello, My Runnable Child!");
    }
}

4.1. 코드 분석

1) MyThread2 클래스 정의

class MyThread2 implements Runnable {

 

• MyThread2 클래스는 Runnable 인터페이스를 구현(implements).
• Runnable은 "쓰레드가 실행할 작업을 정의하는 인터페이스"
• 즉, MyThread2는 "쓰레드가 실행할 작업"을 정의한 클래스

2)  run() 메서드 정의

public void run() {
    try {
        while (true) {
            System.out.println("Hello, Runnable!");
            Thread.sleep(500);
        }
    }
    catch (InterruptedException ie) {
        System.out.println("I'm interrupted");
    }
}

 

• run() 메서드는 쓰레드가 실행할 작업을 정의하는 곳
• while (true) { ... } → 무한 루프를 돌면서 "Hello, Runnable!"을 계속 출력
• Thread.sleep(500); → 0.5초(500ms) 동안 실행을 잠시 멈춤
• catch (InterruptedException ie) { ... } → 만약 강제로 쓰레드가 중단되면 "I'm interrupted"라는 메시지를 출력

3)  ThreadExample2 클래스에서 쓰레드 실행

public class ThreadExample2 {
    public static final void main(String[] args) {

 

• main() 메서드는 프로그램이 실행될 때 가장 먼저 실행되는 곳

4)  쓰레드 객체 생성

Thread thread = new Thread(new MyThread2());

 

• new MyThread2() → 우리가 만든 MyThread2 객체를 생성
• new Thread(new MyThread2()) → Thread 클래스의 생성자에 MyThread2 객체를 넘겨줌
• 이 과정에서 Thread 객체가 MyThread2의 run() 메서드를 실행할 준비를 함

---

5)  쓰레드 시작

thread.start();

 

• start()를 호출하면 쓰레드가 실행됨
• start()를 실행하면 Java가 자동으로 run() 메서드를 실행

---

6)  메인 쓰레드에서 메시지 출력

System.out.println("Hello, My Runnable Child!");

 

• 메인 쓰레드는 별도로 "Hello, My Runnable Child!"를 출력
• 중요한 점은 쓰레드는 독립적으로 실행되기 때문에 출력 순서가 일정하지 않을 수 있음

4.2. 프로그램 실행 결과

Hello, My Runnable Child!
Hello, Runnable!
Hello, Runnable!
Hello, Runnable!
...

 

• "Hello, My Runnable Child!"는 메인 쓰레드에서 실행
• "Hello, Runnable!"은 새로운 쓰레드에서 0.5초마다 반복 출력
• 메인 쓰레드와 MyThread2 쓰레드는 독립적으로 실행된다.

4.3. Runnable을 사용하는 이유

✅ Thread 클래스를 상속받으면 다른 클래스를 상속할 수 없지만, Runnable 인터페이스는 구현하면서 다른 클래스를 상속할 수 있다. ✅ 코드의 구조가 더 유연하고, 유지보수가 쉬워진다. ✅ 여러 쓰레드를 하나의 Runnable 객체에서 실행할 수 있다.

---

4.4. 정리

Java에서 쓰레드를 생성하는 방법에는 Thread 클래스를 상속하는 방법과 Runnable 인터페이스를 구현하는 방법이 있다. Runnable 방식은 더 유연하고, 객체지향적인 코드 작성을 가능하게 한다. 멀티쓰레딩을 잘 활용하면 프로그램의 응답성을 높이고 성능을 향상시킬 수 있다!

5. 부모 thread의 대기

package ch04;

public class ThreadExample4 {
	public static final void main(String[] args) {
		Runnable task = () -> {
			for (int i = 0; i <5; i++) {
				System.out.println("Hello, Lambda Runnable!");
			}
		};
		Thread thread = new Thread(task);
		thread.start();
		try {
			thread.join();
		}
		catch (InterruptedException ie) {
			System.out.println("Parent thread is interrupted");
		}
		System.out.println("Hello, My joined Child!");
	}
}

 

5.1. 자바에서 스레드

• 스레드는 프로그램이 동시에 여러 작업을 수행할 수 있도록 하는 실행 단위
• 자바 프로그램은 기본적으로 메인 스레드(main thread)에서 실행
• 추가로 새로운 스레드를 만들면, 여러 작업을 동시에 실행할 수 있음

5.2. 코드 분석 – 부모 스레드(메인)와 자식 스레드

public static final void main(String[] args) {
    Runnable task = () -> {
        for (int i = 0; i <5; i++) {
            System.out.println("Hello, Lambda Runnable!");
        }
    };
    Thread thread = new Thread(task);
    thread.start();  // (1) 자식 스레드 시작!

    try {
        thread.join(); // (2) 부모 스레드가 자식 스레드가 끝날 때까지 기다림
    } catch (InterruptedException ie) {
        System.out.println("Parent thread is interrupted");
    }

    System.out.println("Hello, My joined Child!"); // (3) 자식 스레드 종료 후 실행됨
}

5.3. 실행 흐름 상세 설명

1️⃣	메인 스레드(main)가 실행됨	🏃‍♂️ 메인 스레드
2️⃣	Runnable task 정의 (람다식)	🏃‍♂️ 메인 스레드
3️⃣	Thread thread = new Thread(task); (새로운 스레드 객체 생성)	🏃‍♂️ 메인 스레드
4️⃣	thread.start(); 호출 → 새로운 스레드 시작!	🏃‍♂️ 메인 스레드 → 🏃‍♂️ 자식 스레드 생성
5️⃣	자식 스레드가 실행됨 (Hello, Lambda Runnable!을 5번 출력)	🏃‍♂️ 자식 스레드
6️⃣	thread.join(); → 메인 스레드는 자식 스레드가 끝날 때까지 기다림(일시 정지)	🏃‍♂️ 메인 스레드(대기)
7️⃣	자식 스레드 종료	🏃‍♂️ 자식 스레드 종료
8️⃣	Hello, My joined Child! 출력	🏃‍♂️ 메인 스레드 다시 실행

5.4. join()이 없다면?

만약 thread.join();을 삭제하면, 메인 스레드는 기다리지 않고 바로 다음 코드(System.out.println("Hello, My joined Child!");)를 실행. 그럼 실행 결과가 섞여서 나올 수도 있음

✅ join() 있는 경우 (자식 스레드가 끝날 때까지 기다림)

Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, My joined Child!  // 🔥 자식 스레드가 끝난 후 출력됨

 

❌  join() 없는 경우 ( 출력 순서가 섞일 가능성 높음 )

Hello, Lambda Runnable!
Hello, My joined Child!  // ⚠️ 부모 스레드가 먼저 실행될 수도 있음
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!

5. thread의 종료: Interrupt

interrupt() 메서드를 사용하여 자식 스레드를 중단할 수 있다. 아래는 이를 확인할 수 있는 예제와 설명이다.

5.1. 코드 설명

public class ThreadExample5 {
    public static void main(String[] args) throws InterruptedException {
        // (1) 자식 스레드의 작업 정의
        Runnable task = () -> {
            try {
                while (true) {
                    System.out.println("Hello, Lambda Runnable!");  // (2) 0.1초마다 출력
                    Thread.sleep(100);  // (3) 0.1초 대기
                }
            }
            catch (InterruptedException ie) {  // (4) InterruptedException 예외 처리
                System.out.println("I'm Interrupted");  // (5) 인터럽트 시 출력
            }
        };

        // (6) 새로운 스레드 생성
        Thread thread = new Thread(task);  // task 실행을 위한 새로운 스레드
        thread.start();  // (7) 자식 스레드 시작

        Thread.sleep(500);  // (8) 메인 스레드 0.5초 대기
        thread.interrupt();  // (9) 자식 스레드에 인터럽트 신호 보냄
        System.out.println("Hello, My interrupted Child!");  // (10) 메인 스레드의 출력
    }
}

5.2. 프로그램 실행 결과

Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
Hello, Lambda Runnable!
I'm Interrupted
Hello, My interrupted Child!

 

6. Multicore 프로그래밍

Multicore 시스템에서는 여러 개의 프로세서 코어가 동시에 작업을 처리할 수 있어, 병렬 실행(Parallel Execution)을 통해 성능을 극대화할 수 있음. 하지만 Multithreading은 여러 스레드가 동시에 실행되기 때문에, 다양한 문제들이 발생할 수 있음.

1. 주요 문제들

• Task 식별: 병렬로 실행할 수 있는 작업을 구분하는 것이 중요
• 균형 문제: 각 작업의 처리 시간과 리소스를 균형 있게 분배해야 함
• 데이터 분할: 효율적인 데이터 분할이 필요
• 데이터 의존성: 작업 간 데이터 의존성을 해결해야 함
• 디버깅 어려움: 여러 스레드가 동시에 실행되어 디버깅이 어려워짐

2. 병렬 처리의 두 가지 유형

• 데이터 병렬성: 동일한 작업을 여러 데이터 세트에 대해 동시에 처리.
• 작업 병렬성: 서로 다른 작업을 동시에 실행.

3. 분산 시스템과 클라우드

현대 시스템에서는 분산 시스템과 클라우드를 통해 여러 서버가 병렬로 작업을 분담합니다. 이는 Multicore 시스템을 넘어서는 분산 처리 환경을 의미하며, 데이터 의존성과 균형을 맞추는 것이 중요

 

6. Amdahl's의 공식

코어는 무조건 많을수록 좋을까?

 

Amdahl's 법칙은 병렬 처리에서 성능 향상의 한계를 설명함. 코어 수가 많아질수록 성능이 비례해 증가하는 것이 아니라, 병렬 처리할 수 있는 부분의 한계로 인해 성능 향상에 한계가 존재.

Amdahl's 법칙 공식:

Stotal=1(1−P)+PNS_{total} = \frac{1}{(1 - P) + \frac{P}{N}}Stotal​=(1−P)+NP​1​

• S_total: 전체 성능 향상 비율
• P: 병렬화가 가능한 부분의 비율
• N: 사용하는 프로세서(코어)의 수

핵심 포인트

• 코어가 많다고 4배 빨라지지 않는다: 예를 들어, 병렬화가 가능한 부분이 75%라면, 4개의 코어로는 성능이 약 3배 향상. 나머지 25%의 순차적 처리 부분은 여전히 한 코어에서 처리되어 병렬 처리의 성능 향상에 제한을 줌.
• 병렬 처리의 한계: 병렬 처리가 가능한 부분이 많지 않으면, 코어 수가 아무리 많아도 성능 향상이 제한적.