[Java 고급편] 스레드 생성과 실행

프로세스와 스레드

✳️ 프로세스

• 운영체제 안에서 실행 중인 프로그램
• 실행 중인 프로그램의 인스턴스
• 각 프로세스는 독립적인 메모리 공간을 갖고 있음 👉 프로세스가 서로의 메모리에 직접 접근 X
• 운영체제에서 별도의 작업 단위로 분리해서 관리됨 
• 프로세스는 하나 이상의 스레드를 반드시 포함 

❇️ 프로세스의 메모리 구성

• 코드 섹션 : 실행할 프로그램의 코드가 저장되는 부분
• 데이터 섹션 : 전역 변수 및 정적 변수가 저장되는 부분 (기타 부분)
• 힙 : 동적으로 할당되는 메모리 영역
• 스택 : 메서드 호출 시 생성되는 지역 변수와 반환 주소가 저장되는 영역 (스레드에 포함)

 

✳️ 스레드 

• 프로세스 내에서 실행되는 작업의 단위
• 한 프로세스 내에서 여러 스레드 존재 가능 👉 프로세스가 제공하는 동일한 메모리 공간 공유

 

❇️ 메모리 구성

• 공유 메모리 : 같은 프로세스의 코드 섹션, 데이터 섹션, 힙(메모리)은 프로세스 안의 모든 스레드가 공유함
• 개별 스택 : 각 스레드는 자신의 스택을 갖고 있음

---

✳️ 자바 메모리 구조

• 메서드 영역 : 프로그램을 실행하는 데 필요한 공통 데이터 관리. 프로그램의 모든 영역에서 공유
  • 클래스 정보 : 클래스의 실행 코드(바이트 코드), 필드, 메서드, 생성자 코드 등 모든 실행 코드
  • static 영역 : static 변수들 보관
  • 런타임 상수 풀 : 프로그램을 실행하는 데 필요한 공통 리터럴 상수 보관
• 스택 영역 : 지역 변수, 중간 연산 결과, 메서드 호출 정보 등을 포함
• 힙 영역 : 객체(인스턴스)와 배열이 생성되는 영역. 가비지 컬렉션이 이루어지는 주요 영역이며 더 이상 참조되지 않는 객체는 제거됨

 

 

 

스레드 생성하기 - Thread 상속 

public class HelloThread extends Thread{
	@Override
    public void run(){
    	System.out.println(Thread.currentThread().getName() + " : run()");
    }
}

package thread.start;

public class HelloThreadMain {
	public static void main(String[] args) {
        System.out.println(Thread.currentThread().getName() + ": main() start");
        
        HelloThread helloThread = new HelloThread();
        System.out.println(Thread.currentThread().getName() + ": start() 호출 전");
        
        helloThread.start();
        System.out.println(Thread.currentThread().getName() + ": start() 호출 후");
        
        System.out.println(Thread.currentThread().getName() + ": main() end");
    }
}

// >>> main: main() start
// >>> main: start() 호출 전
// >>> main: start() 호출 후
// >>> Thread-0: run()
// >>> main: main() end

👉 start() 를 호출하면 HelloThread 스레드가 run() 메서드를 실행

👉 스레드 간 실행 순서는 보장 못함 (= 출력 순서 일정 X)

⛔ main 스레드가 다른 스레드에게 실행 지시 후 멈추지 않고 계속 수행

 

• main() 메서드는 main이라는 이름의 스레드가 실행 👉 프로세스가 작동하려면 최소한 하나는 있어야 함

 

• HelloThread 스레드 객체를 생성한 후 start() 메서드를 호출하면 자바는 스레드를 위한 별도의 스택 공간 할당
• 스레드에 이름을 부여하지 않으면 자바는 스레드에 Thread-0, Thread-1과 같은 임의의 이름 부여
• Thread-0 스레드는 run()  메서드의 스택 프레임을 스택에 올리면서 run() 메서드 시작 👉 main 스레드가 run() 메서드를 실행하는 것이 아님 !
• main 스레드는 다른 스레드에게 일을 시작하라고 지시만 하고 start() 메서드를 빠져나옴 👉 기다리지 않음 !
• main 스레드와 Thread-0 스레드는 동시에 실행됨

🌟 스레드 간의 실행 순서는 얼마든지 달라질 수 있다 👉 멀티 스레드 

 

---

만약.. start() 대신 run() 메서드를 직접 호출하게 된다면 ..? 

 

• 별도의 스레드가 run()을 실행하는 것이 아니라, main 스레드가 run() 메서드를 호출

---

✳️ 데몬 스레드

• 백그라운드에서 보조적인 작업 수행
• 모든 user 스레드가 종료되면 데몬 스레드는 자동으로 종료됨 
• ex) 파일이나 메모리 정리하는 작업

JVM은 데몬 스레드의 실행 완료를 기다리지 않고 종료됨.
데몬 스레드가 아닌 모든 스레드가 종료되면 자바 프로그램도 종료됨

 

✳️ 사용자 스레드

• 프로그램의 주요 작업 수행
• 작업이 완료될 때까지 실행됨
• 모든 user 스레드가 종료되면 JVM도 종료됨

 

 

 

스레드 생성하기 - Runnable 인터페이스 구현하기

Thread 클래스를 상속하는 방식보다 Runnable 인터페이스를 구현하는 것이 더 나음 !

public interface Runnable{
	void run();
}

public class HelloRunnable implements Runnable{
	
    @Override
    public void run(){
    	System.out.println(Thread.currentThread().getName() + ": run()");
    }
}

public class HelloRunnableMain{
	
    public static void main(String[] args){
    	System.out.println(Thread.currentThread().getName() + ": main() start");
        
        HelloRunnable runnable = new HelloRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
        
        System.out.println(Thread.currentThread().getName() + " : main() end");
    }
}
// >>>  main: main() start
// >>>  main: main() end
// >>>  Thread-0: run()

• 스레드와 해당 스레드가 실행할 작업이 서로 분리되어있음
• 스레드 객체를 생성할 때 실행할 작업을 생성자로 전달

---

✳️ Thread 상속 vs Runnable 구현 

• Thread 클래스 상속 방식
  • Thread 클래스를 상속받아 run() 메서드만 재정의하면 됨
  • 상속의 제한 있음 👉 자바는 단일 상속만 허용하므로 이미 다른 클래스를 상속받고 있는 경우 Thread 상속 불가
  • 유연성 떨어짐
• Runnable 인터페이스 구현 방식
  • 상속의 자유로움
  • 스레드와 실행할 작업을 분리하여 코드의 가독성 높임
  • 여러 스레드가 동일한 Runnable 객체를 공유할 수 있어 자원 관리 효율적
  • 코드가 약간 복잡해짐 👉 Runnable 객체를 생성하고 이를 Thread에 전달하는 과정 추가 

 

 

 

멀티스레드 프로그램 예시

✳️ Thread 상속

1. `Thread` 클래스를 상속받은 `CounterThread` 라는 스레드 클래스를 만들기
2. 이 스레드는 1부터 5까지의 숫자를 1초 간격으로 출력해야 함.  `log()` 기능을 사용해서 출력
3. `main()` 메서드에서 `CounterThread` 스레드 클래스를 만들고 실행

 

public class StartTest1Main {
	public static void main(String[] args){
    	CounterThread thread = new CounterThread();
        thread.start();
    }
    
    static class CounterThread extends Thread {
    	
        @Override
        public void run(){
        	for(int i=1; i<=5; i++){
            	log("value : " + i);
                try{
                	Thread.sleep(1000);
                }catch(InterruptedException e){
                	throw new RuntimeException(e);
                }
            }
        }
    }
}

 

✳️ Runnable 구현

1. `CounterRunnable` 이라는 이름의 클래스를 만들기. 이 클래스는 `Runnable` 인터페이스를 구현해야 함
2. `CounterRunnable` 은 1부터 5까지의 숫자를 1초 간격으로 출력. `log()` 기능을 사용해서 출력.
3. `main` 메서드에서 `CounterRunnable` 의 인스턴스를 이용해서 `Thread` 를 생성하고 실행.
4. 스레드의 이름은 "counter"로 지정.

 

public class StartTest2Main{
	public static void main(String[] args){
    	Thread thread = new Thread(new CounterRunnable(), "counter");
        thread.start();
    }
    
    static class CounterRunnable implements Runnable{
    	public void run(){
        	for(int i=1; i<=5; i++){
            	log("value : " + i);
                try{
                	Thread.sleep(1000);
                }catch (InterruptedException e){
                	e.printStackTrace();
                }
            }
        }
    }
}

 

✳️ Runnable 익명 클래스 구현

public class StartTest3Main{
	public static void main(String[] args){
    	Runnable runnable = new Runnable(){
        	@Override
            public void run(){
            	for(int i=1; i<=5; i++){
                	log("value : " + i);
                    try{
                    	Thread.sleep(1000);
                    }catch (InterruptedException e){
                    	e.printStackTrace();
                    }
                }
            }
        };
        
        Thread thread = new Thread(runnable, "counter");
        thread.start();
    }
}

 

✳️ 여러 스레드 사용

 Thread-A , Thread-B 두 스레드를 만들기
Thread-A 는 1초에 한 번씩 "A"를 출력
Thread-B 는 0.5초에 한 번씩 "B"를 출력
강제 종료할 때까지 계속 실행.

public class StartTest4Main{

	public static void main(String[] args){
    	Thread threadA = new Thread(new PrintWork("A", 1000), "Thread-A");
        Thread threadB = new Thread(new PrintWork("B", 500), "Thread-B");
        
        threadA.start();
		threadB.start();
    }
    
    static class PrintWork implements Runnable{
		private String content;
        private int sleepMs;
        
        public PrintWork(String content, int sleepMs){
        	this.content = content;
            this.sleepMs = sleepMs;
        }
        
        @Override
        public void run(){
        	while(true){
            	log(content);
                try {
					Thread.sleep(sleepMs);
                } catch (InterruptedException e) {
                	throw new RuntimeException(e);
                }
            }
        }
	}	
}