중요한 용어, class, method

Process

: 실행 중인 프로그램
: resource + thread(여러개)

우리가 가진 프로그램을 실행시키기 위해서는 OS로부터 resource를 할당 받아야 한다. 할당 받아서 실행한 프로그램을 process라고 한다.

process에는 최소 한 개 이상의 thread가 존재한다.
thread가 딱 한 개 있는 경우 : single-thread process
thread가 두 개 이상 있는 경우 : multi-thread process
-> 지금까지 작성했던 프로그램(코드)들 안에는 thread가 하나이다. 코드에서 thread를 추가적으로 만들지 않았기 때문이다.

resource
1. code : 프로그램 실행 코드
2. data : 프로그램을 실행하기 위한 데이터
3. Heap : 동적 메모리 영역
4. Stack : 함수 스택 영역

process의 종료

: 내부에서 파생된 모든 User define thread가 종료되는 순간 종료된다.

CPU (core)

: 1개의 core는 한 순간에 한가지 일만 수행할 수 있다.

만약, Single Core인 경우를 가정하면
우리가 사용하는 여러 프로그램이 마치 동시에 실행되는 것처럼 보인다.
ex) Excel, powerpoint, game, music, ...
-> time slicing (시분할) 기법
-> Multitasking (core의 개수와는 상관 없다.)

Multiprocessing
: 프로그램 두개가 시간적으로 동시에 실행되는 것
core가 한 개이면 안된다. 여러개의 core여야 한다.

Thread

: execution stack을 별도로 가지고 있는 실행 흐름

stack은 thread 별로 할당이 된다. main도 하나의 실행 흐름(thread)이다. -> main thread

프로그램 안에 여러 개의 thread가 존재할 수 있게 되는 것이다. 여러 개의 실행흐름을 가지고 작업을 나누어서 동시에 수행 하는 것이 더 효율적이다.

thread가 무조건 많을수록 좋지는 않다.
stack 영역이 thread마다 할당이 되어야 하니까 resource가 부족해질 수 있다.
-> 적정양의 thread를 유지해야 한다.

Multi-threading

: 하나의 프로그램에서 여러 개의 thread가 존재할 때, 시간상 동시에 실행이 되는 것처럼 하는 것
time slicing(시분할)로 multitasking이 일어나거나
여러개의 core로 multiprocessing이 일어날 수도 있다.

장점

• 효율적인 처리가 가능하다.
• 사용자에 대한 응답속도가 좋아진다.

단점

• 프로그램이 어렵다.
• 공유 자원에 대한 "동기화 처리"가 어렵다. -> 이로 인한 교착문제(deadlock)
• 제어가 까다롭다.

Java에서 Thread 만들어 사용하려면?

thread 생성

thread를 만들 때, JVM이 thread를 생성하고, 생성된 thread가 main을 호출한다. 이 thread를 main thread라고 하는 것이다.

Java에서 thread는 instance이다. -> 이 instance를 만들어내는 class가 존재한다.
=> Thread class

1. Thread class를 상속해서 User define thread class를 이용한다.
   -> 잘 쓰지 않는다. Java는 다중 상속이 안 되기 때문에 thread class를 상속하면 다른 class를 상속 받을 수 없게 된다. class를 직접적으로 상속받아서 사용하면 tightly coupled 문제가 발생해 재사용하기가 어려워진다.
2. Runnable interface를 구현해서 User define class를 만들고, 이 class의 instance를 만든다.
   -> 만든 instance를 new Thread()의 인자로 넣어서 사용한다.

코드로 알아보기

1. Thread class 상속해서 생성

• 새로운 thread가 생성되지 않는 코드

package lecture0714;

class MyThread extends Thread{
	
	@Override
	public void run() {
		System.out.println("Hello");
	}
}

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

1. main이 시작하면 call stack에 main이 쌓인다.
2. MyThread의 instance가 생성된다.
3. t.run()을 직접 호출하면 call stack에 쌓이고, 새로운 실행 흐름이 만들어지지 않는다.

• 새로운 thread가 생성되는 코드

package lecture0714;

class MyThread extends Thread{
	
	@Override
	public void run() {
		System.out.println("Hello");
	}
}

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

start()를 호출해야 새로운 thread / 실행 흐름이 생겨나게 된다.

start()
: thread 생성, stack 할당, run() 호출

2. Runnable interface로 생성

• 새로운 thread 생성하는 코드

package lecture0714;

class MyThread2 implements Runnable {

	@Override
	public void run() {
		System.out.println("이것도 실행!");
	}
}

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

		MyThread2 a = new MyThread2();  // 아직 thread가 아니다.
		Thread t1 = new Thread(a);
		t1.start();
		
		System.out.println("안녕하세요!");
	}
}

thread 연습 코드

package lecture0714;

class ThreadEx_01_1 extends Thread {
	
	@Override
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println(getName());
		}
	}
}

class ThreadEx_01_2 implements Runnable {
	
	@Override
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println(Thread.currentThread().getName());  // Thread class의 static method. 이 코드를 실행시키는 thread를 지칭한다.
		}
	}
}

public class ThreadExam01 {
	
	public static void main(String[] args) {
		
		ThreadEx_01_1 t1 = new ThreadEx_01_1();
		
		ThreadEx_01_2 r = new ThreadEx_01_2();
		Thread t2 = new Thread(r);
		
		// 셋 중에서 어떤 것이 먼저 실행될지는 모른다.
		// 스케줄러에 의해서 선택되어서 실행된다.
		t1.start();
		t2.start();		
		System.out.println("main thread 종료");
	}
}

Thread의 상태전이도

Single core & Multi core

single thread에서 처리해야 할 작업이 두개이다. (A,B)

• single core에서 thread 한 개 일때
  
• single core에서 thread 두 개 일때
  
  => A와 B가 둘 다 끝나는 시점은 첫번째 방법이 더 빠르다.
  context switching 작업이 두번째 방법이 더 빈번하게 일어나기 때문이다. multi core가 아니면 의미가 없다.
• multi core에서 thread 두 개 일때
  
  빨리 끝날 수 있다. 현재 대부분의 시스템은 multi core로 되어 있다.

thread 우선순위

: setPriority()
single core에서만 가능하다. multi core에서는 의미가 없다. 제대로 동작하지 않는다.

Daemon Thread (데몬 Thread)

: 다른 일반 thread의 보조적인 작업을 하기 위해 사용한다.
해당 daemon thread를 파생시킨 thread가 종료되면 같이 종료된다.
ex) Garbage collecttion, 자동 저장 기능

t1.setDaemon(true);

연습 코드

package lecture0714;

// Daemon Thread 알아보기
public class ThreadExam02 implements Runnable {
	
	static boolean autoSave = false;
	
	public static void main(String[] args) {
		Thread t = new Thread(new ThreadExam02());
		
		t.setDaemon(true);
		
		t.start();
		
		for(int i=0; i<10; i++) {
			try {
				Thread.sleep(1000);  // main thread를 재운다.
			} catch (Exception e) {
				
			}
			System.out.println(i);
			
			if(i == 5) {
				autoSave = true;
			}
		}
	}
	
	@Override
	public void run() {
		while(true) {
			try {
				Thread.sleep(3000);  // t thread를 재운다.
			} catch (InterruptedException e) {
				
			}
			
			if(autoSave) {
				System.out.println("자동저장되었습니다!");
			}
		}
	}
}

기억해야 하는 thread의 method

sleep(long millisecond)

: 일정 시간동안 thread를 중지시킨다.

sleep에 들어가면 쿨쿨 잔다. sleep에서 깨어나는 조건
1. 지정된 시간이 다 되었다.
2. Thread에 대해 interrupt()가 호출된다. (InterruptedExceiption이 발생)
-> 이 이유 때문에 sleep은 항상 try~catch 문과 함께 쓰여야 한다.

sleep 상태 전이도

: sleep에서 깨어나는 조건이 되면 Running 상태로 가는 것이 아니라 Runnable 상태로 돌아간다. 다시 Runnable 상태의 thread들과 선택받기 위해 경쟁한다.

sleep 주의해야 할 코드

package lecture0714;

class ThreadEx_03_1 extends Thread {
	
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
		System.out.println("<<Thread 1 종료>>");
	}
}

class ThreadEx_03_2 extends Thread {
	
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("|");
		}
		System.out.println("<<Thread 2 종료>>");
	}
}

public class ThreadExam03 {
	
	public static void main(String[] args) {
		
		ThreadEx_03_1 t1 = new ThreadEx_03_1();
		ThreadEx_03_2 t2 = new ThreadEx_03_2();
		
		t1.start();
		t2.start();
		
		try {
			t1.sleep(2000);  // 현재 실행되고 있는 thread를 재우는 것이기 때문에 main thread가 잔다.
			// t1.sleep(2000) 이나 t2.sleep(2000) 이나 Thread.sleep(2000) 이나 모두 같다.
		} catch (Exception e) {
			
		}
		System.out.println("<<main Thread 종료>>");
	}
}

• 해결 코드
  sleep 시키려는 thread 코드에 sleep을 넣어주어야 한다.

package lecture0714;

class ThreadEx_03_1 extends Thread {
	
	@Override
	public void run() {		
		try {
			Thread.sleep(2000);
		} catch (Exception e) {
			
		}
		
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
		System.out.println("<<Thread 1 종료>>");
	}
}

class ThreadEx_03_2 extends Thread {
	
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("|");
		}
		System.out.println("<<Thread 2 종료>>");
	}
}

public class ThreadExam03 {
	
	public static void main(String[] args) {
		
		ThreadEx_03_1 t1 = new ThreadEx_03_1();
		ThreadEx_03_2 t2 = new ThreadEx_03_2();
		
		t1.start();
		t2.start();
		
		System.out.println("<<main Thread 종료>>");
	}
}

interrupt()

: Thread 실행 후 작업이 끝나기 전에 해당 thread를 중지시키고 싶을 때 사용한다.

interrupt()는 직접 중지 시키지 않고, thread의 내부상태 값인 "Interrupted state"를 변경한다.

🤡Thread가 interrupt가 되었는지 확인하는 method

1. interrupted() - Thread class의 static
   : 현재 수행 중인 thread가 interrupt가 되었는지 여부를 알아낸다.
   interrupt 여부를 조사하고 상태값을 무조건 False로 바꾼다.

2. isInterrupted() - Thread class의 static X
   : 특정 thread가 interrupt가 되었는지 여부를 알아낸다.
   interrupt 여부를 조사만 하고 상태값만 리턴한다.(True/False)

stop() - thread의 강제 중지
-> 의도치 않은 상황이 발생할 수 있어 현재는 사용하지는 않는다. (deprecated)
suspend() - thread의 일시 중지
resume() - 일시 중지된 thread의 재시작
start() - thread의 시작

• 코드
  : deprecated 된 것 사용

package lecture0714;

class ThreadEx_05 implements Runnable {

	@Override
	public void run() {
		while(true) {  // 1초 잤다 일어나서 자신의 이름을 찍는다.
			System.out.println(Thread.currentThread().getName());
			
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				
			}
		}
	}
}

public class ThreadExam05 {
	
	public static void main(String[] args) {
		
		ThreadEx_05 r = new ThreadEx_05();
		Thread t1 = new Thread(r, "*");  // thread의 이름을 *로 짓는다.
		Thread t2 = new Thread(r, "**");
		Thread t3 = new Thread(r, "***");
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			Thread.sleep(2000);  // main thread 재우기
			t1.suspend();  // t1을 일시 중지
			Thread.sleep(2000);
			t2.suspend();
			Thread.sleep(2000);
			t1.resume();  // t1이 다시 동작하도록 설정
			Thread.sleep(2000);
			t1.stop();
			t2.stop();
			Thread.sleep(2000);
			t3.stop();
		} catch (Exception e) {

		}
	}
}

: no deprecated 사용

package lecture0714;

class ThreadEx_06 implements Runnable {

	volatile boolean suspended = false;
	volatile boolean stopped = false;
	
	@Override
	public void run() {
		while(!stopped) {  // 1초 잤다 일어나서 자신의 이름을 찍는다.
			if(!suspended) {
				System.out.println(Thread.currentThread().getName());
				
				try {
					Thread.sleep(1000);
				} catch (Exception e) {
					
				}
			}
		}
	}
	
	public void suspend() {
		suspended = true;
	}
	
	public void stop() {
		stopped = true;
	}
	
	public void resume() {
		suspended = false;
	}
}

public class ThreadExam06 {

	public static void main(String[] args) {
		
		ThreadEx_06 r1 = new ThreadEx_06();
		ThreadEx_06 r2 = new ThreadEx_06();
		ThreadEx_06 r3 = new ThreadEx_06();
		
		Thread t1 = new Thread(r1, "*");  // thread의 이름을 *로 짓는다.
		Thread t2 = new Thread(r2, "**");
		Thread t3 = new Thread(r3, "***");
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			Thread.sleep(2000);  // main thread 재우기
			r1.suspend();  // t1을 일시 중지
			Thread.sleep(2000);
			r2.suspend();
			Thread.sleep(2000);
			r1.resume();  // t1이 다시 동작하도록 설정
			Thread.sleep(2000);
			r1.stop();
			r2.stop();
			Thread.sleep(2000);
			r3.stop();
		} catch (Exception e) {

		}	
	}
}

volatile이 없을 때는 제대로 실행되지 않는다.
멀티코어 프로세서에서는 속도를 높이기 위해 캐시를 사용해 필드값을 바꾸기 때문에 제대로 작동되지 않았다. volatile을 붙여서 직접 메모리에 접근하게 바꿔준다.

interrupt 예제 코드

package lecture0714;

import javax.swing.JOptionPane;

class ThreadEx_04 extends Thread {
	
	@Override
	public void run() {
		int i = 10;
		
		while(i != 0 && !isInterrupted()) {  // i가 0이 아니고, interrupt가 걸리지 않았으면 계속 반복한다.
			System.out.println(--i);
			
			try {
				Thread.sleep(4000);
				// sleep에서 interrupt가 걸리면 interrupted 상태가 다시 false가 된다.
			} catch (Exception e) {
				interrupt();
			}
			// for(long k=0; i<2500000000L; k++);  // 시간 지연
		}
		System.out.println("카운트가 종료되었어요!");
	}
}

public class ThreadExam04 {
	
	public static void main(String[] args) {
		
		Thread t = new ThreadEx_04();
		
		t.start();
		
		String input = JOptionPane.showInputDialog("값을 입력하세요!");  // 값을 입력할 때까지 main thread는 여기서 blocking 된다.
		System.out.println("입력값은 : " + input);
		
		t.interrupt();  
		// thread t의 내부상태 정보(interrupted 상태)를 true로 바꾼다.
		
		System.out.println("Thread 상태값은 : " + t.isInterrupted());
	}
}

yield()

: Thread가 자신에게 주어진 실행 시간을 다 쓰지 않고 다른 thread에게 양보한다.
-> 프로그램의 응답성을 높이기 위해 사용된다.

yield 상태 전이도

yield 예제 코드

위의 no deprecated 예제에서는 suspend가 된 상태라면 출력만 되지 않고 while문은 계속해서 돌게 된다 -> busy waiting
=> yeild로 다른 thread에게 양보한다.

package lecture0714;

class ThreadEx_06 implements Runnable {

	volatile boolean suspended = false;
	volatile boolean stopped = false;
	
	@Override
	public void run() {
		while(!stopped) {  // 1초 잤다 일어나서 자신의 이름을 찍는다.
			if(!suspended) {
				System.out.println(Thread.currentThread().getName());
				
				try {
					Thread.sleep(1000);
				} catch (Exception e) {
					
				}
			} else {
				Thread.yield();  // 일시정지라서 runnable 상태로 바뀌면서 빠진다.
			}
		}
	}
	
	public void suspend() {
		suspended = true;
	}
	
	public void stop() {
		stopped = true;
	}
	
	public void resume() {
		suspended = false;
	}
}

public class ThreadExam06 {

	public static void main(String[] args) {
		
		ThreadEx_06 r1 = new ThreadEx_06();
		ThreadEx_06 r2 = new ThreadEx_06();
		ThreadEx_06 r3 = new ThreadEx_06();
		
		Thread t1 = new Thread(r1, "*");  // thread의 이름을 *로 짓는다.
		Thread t2 = new Thread(r2, "**");
		Thread t3 = new Thread(r3, "***");
		
		t1.start();
		t2.start();
		t3.start();
		
		try {
			Thread.sleep(2000);  // main thread 재우기
			r1.suspend();  // t1을 일시 중지
			Thread.sleep(2000);
			r2.suspend();
			Thread.sleep(2000);
			r1.resume();  // t1이 다시 동작하도록 설정
			Thread.sleep(2000);
			r1.stop();
			r2.stop();
			Thread.sleep(2000);
			r3.stop();
		} catch (Exception e) {

		}	
	}
}

join()

: 다른 thread를 지정해서 내가 수행되고 있는 중간에 끼어들 수 있게 한다.
static method가 아니다.

• join()
  : 현재 실행 되고 있는 thread를 일시적으로 block 시킨다.
• join(long 초)

sleep은 특정 thread를 지정해서 재울 수가 없다. 현재 실행되고 있는 thread를 재운다. => 그래서 sleep은 static method이다.
현재 thread가 block 되는 것은 join과 동일하다.

join 상태 전이도

join 예제 코드

package lecture0715;

class ThreadEx_07_1 extends Thread {
	
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
	}
}

class ThreadEx_07_2 extends Thread {
	
	@Override
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("|");
		}
	}
}

public class ThreadExam07 {
	
	public static void main(String[] args) {
		Thread t1 = new ThreadEx_07_1();
		Thread t2 = new ThreadEx_07_2();
		
		t1.start();
		t2.start();
		
		try {
			t1.join();  // main thread를 멈추고 t1을 포함시킨다.
			t2.join();
		} catch (Exception e) {
			// TODO: handle exception
		}
		System.out.println("<<main 종료>>");
	}
}

• join을 어디에서 사용하면 좋을까?

package lecture0715;

class ThreadEx_08_1 extends Thread {
	
	final static int MAX_MEMORY = 1000;  // 최대 메모리 용량
	int usedMemory = 0;  // 사용된 메모리량
	
	@Override
	public void run() {
		while(true) {  // 무한 루프이면 끝나지 않기 때문에 이 thread는 daemon thread로 만들어줘야 한다.
			try {
				Thread.sleep(10000);  // 10초 동안 잔다.
			} catch (Exception e) {  // 자는 동안 누군가 깨워서 interrupt 발생할 경우
				System.out.println("interrupt에 의해서 깨어났어요!");
			}
			gc();
			System.out.println("메모리 청소 완료! 현재 사용 가능한 메모리량 : " + freeMemory());
		}
	}
	
	// garbage collection
	private void gc() {  // 클래스 내부에서만 사용할 경우에는 private으로 잡는 것이 좋다.
		usedMemory -= 300;
		if(usedMemory < 0) {
			usedMemory = 0;
		}
	}
	
	public int totalMemory() { return MAX_MEMORY; }	
	public int freeMemory() { return MAX_MEMORY - usedMemory; }
}

public class ThreadExam08 {

	public static void main(String[] args) {
		
		ThreadEx_08_1 t = new ThreadEx_08_1();
		t.setDaemon(true);
		t.start();
		
		int requiredMemory = 0;
		
		for(int i=0; i<20; i++) {
			requiredMemory = (int)(Math.random() * 10) * 20;  // 0보다 같거나 크고 200보다 작은 정수
			
			// 필요한 memory가 사용할 수 있는 양보다 크거나
			// 현재 전체 메모리양의 60% 이상을 사용하고 있을 때 gc를 실행한다.
			if(requiredMemory > t.freeMemory() || t.freeMemory() < t.totalMemory() * 0.4) {
				t.interrupt();  // 여기에서는 main thread는 gc() 실행이 끝날때까지 기다리지 않는다.
				try {
					t.join(100);  // 이 코드로 main이 gc() 실행을 기다리게 된다.
				} catch (Exception e) {
					
				}
			}
			t.usedMemory += requiredMemory;
			System.out.println("사용된 메모리량 : " + t.usedMemory);
		}
	}
}

Math.random()
0.0보다 같거나 크고 1.0보다 작은 실수