⭐Thread(스레드)

💜thread(스레드)

프로그램 하나에서 동시에 여러 개를 처리하는 단위를 의미한다.
thread 는 우리가 호출하는 것이 아니다.
죽은 thread는 재활용할 수 없다.

→ 예를 들어 하나의 게임에서 여러 접속자가 있다면 접속자 한 명 한 명을 thread라 한다.
→ 가상 머신(JVM)을 통해 어떤 스레드(thread)가 실행 될 지 정해진다.
→ 스레드를 통해 프로그램의 병렬처리가 가능하다.

→ start를 하는 순간 t1, t2, t3 는 JVM에 뽑히기 위한 경쟁을 한다.

💙병렬(Parallel) VS 병행(Concurtency)

1) 병렬
→ H/W(하드 웨어)적인 개념이다.
(멀티 코어에서 사용)
→ 실제로 동시에 여러 작업이 일어나는 것을 의미한다.

2) 병행
→ S/W(소프트 웨어)적인 개념이다.
→ 여러 작업이 동시에 진행되는 것처럼 보이도록 하는 것을 의미한다.
(예를 들어 시분할 시스템처럼 사용자에게 병렬적인 실행을 느끼게 해준다.)
→ 멀티 코어가 아님에도 불구하고 멀티 코어인 것처럼 느끼게 해주는 것이 목적이다.
(시분할 시스템을 쓰는 이유가 멀티 태스킹을 하기 위해서이다.)
→ 응답성 높이기 위해 thread를 사용한다.
(프로그램이 여러 스레드를 사용하면, 각 스레드는 독립적으로 실행되어 병행성을 실현할 수 있기 때문이다.)

💜process(프로세스)

thread 의 집합을 말한다.

→ 사용자가 작성한 프로그램이 운영체계에 의해 메모리 공간을 할당받아 실행 중인 것을 의미한다.
→ 프로세스가 실행하기 위해서 반드시 CPU 와 메모리가 필요하다.
→ 운영체계(O/S)가 실행 할 특정 프로세스를 정한다.
→ 프로세스 관리는 운영체계(O/S)가 정하는 순서에 따라 이루어진다.
이를 스케줄링 이라고 한다.

→ 위 그림에서 시분할 시스템에 대해 설명할 수 있다.

💙시분할 시스템

시분할 시스템 : 여러 프로세스가 번갈아 가면서 실행되는 시스템이다.

→ 시분할 시스템은 사실 상 시간 당 실행 중인 프로세스가 하나밖에 없다.
(너무 빠르게 되기에 우리가 느끼지 못할 뿐이다.)
위 그림에서 보고 다시 이해를 하자면 time1이라는 시간 동안 B만 실행되고 있는데 이를 이야기한다.
→ 즉, 시간을 쪼개서 시간마다 실행할 프로그램을 정해주는 일을 하는 것이다.
→ 다른 코어에서 같은 시간에 실행될 수 있다.

💜스레드 만들기

run( ) 안에도 다른 스레드를 만들 수 있다.
(main 메소드도 thread 인데 우리가 만든 것처럼)

1) 방법 1

class ExtendThread extends Thread{
	// run() 를 오버라이딩하여 재정의
	public void run() {
		System.out.println("Thread 클래스를 상속 : " + Thread.currentThread().getName());
	}
}
public class ExtendThreadTest {

	public static void main(String[] args) {
		ExtendThread et = new ExtendThread();
		et.start();
		System.out.println("end of main : " + Thread.currentThread().getName());

	}
}

→ 스레드를 상속받으면 사용가능하다.
→ start( ) : thread가 시작된다.
이때, 위에서 보면 et 라는 스레드가 생긴다.
스레드가 생긴 후 가상머신이 어떤 스레드를 사용할 지 정해야 한다.
⇒ 즉, main 스레드 와 et 스레드 2개가 생기고 이를, 듀얼 스레드라고 한다.
→ 이후 ExtendThread 클래스의 run()이 실행되고 종료되면 바로 ExtendThread가 소멸된다.
→ currentThread( ) : 현재 이 일을 수행하는 스레드 객체를 구할 수 있다.

💙Runnable

2) 방법 2_1

public class RunnableThreadTest {

	public static void main(String[] args) {
		// Thread 생성자에 RunnableThread 인스턴스를 파라미터로 전달
		Thread t = new Thread(new RunnableThread());
		t.start();
		System.out.println("end of main");
	}

}

class RunnableThread implements Runnable{
	// run() 를 오버라이딩하여 재정의
	@Override
	public void run() {
		System.out.println("Runnable 인터페이스를 구현");
	}
}

→ 인터페이스 Runnable 의 run( ) 를 오버라이딩 한다.
→ Runnable : 스레드가 할 일을 나타내는 객체이다.

방법1 보다 Runnable이 더 좋을 수도 있다.
자바에서는 단일 상속만 허락하는데 이미 다른 것을 상속받은 경우, Runnable을 구현한 클래스의 인스턴스를 생성하고 그 인스턴스를 Thread 클래스의 생성자에 전달하여 Thread 객체를 생성하고 실행할 수 있다.
이러면 더 유연한 관리를 할 수 있다.

2) 방법 2_2

class ThreadEx1 extends Thread{
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println("t1 : " + getName());
		}
	}
}

class ThreadEx1_2 implements Runnable{
	public void run() {
		for(int i=0; i<5; i++) {
			System.out.println("t2 : " + Thread.currentThread().getName());
		}
	}
}

public class CreateThread {
	public static void main(String[] args) {
		ThreadEx1 t1 = new ThreadEx1();
		
		Runnable r = new ThreadEx1_2();
		Thread t2 = new Thread(r);
		
		t1.start();
		t2.start();
		
		System.out.println(Thread.currentThread().getName());
	}
}

→ 다음 결과를 보면 Thread가 순서대로 작동되지 않음을 알 수 있다.
→ 그리고 스레드가 할 일이 아직 끝나지 않았다면 프로그램은 종료되지 않는다.

💜thread state

1) NEW
2) RUNNABLE
3) BLOCK
4) WAITING
5) TIMED_WATING
6) TERMINATED

public class NormalProcess{

	public static void main(String[] args) throws Exception{
		String input = JOptionPane.showInputDialog(
				"아무 값이나 입력하세요."
		);
		//위가 실행되는 동안 밑에 코드가 실행되지 않는게 블로킹이다.
		System.out.println("입력하신 값은 " + input + "입니다.");
		
		for(int i=10; i>0; i--) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			} catch (Exception e) {
				
			}
		}
	}
}

→ 위 코드에서 사용자에게 값을 입력 받으면 for문을 돌면서 숫자를 출력하고 Thread.sleep(1000) 을 통해 1초 동안 일시 정지가 되고 다시 숫자를 출력한다.
→ JOptionPane이 실행되는 동안 밑의 코드들은 실행되지 않는데 이를 입출력 블로킹이라고 한다.
→ Thread.sleep(millisecond) : 1/1000 초 동안 스레드를 잠들게 한다.(일시 정지 시킨다.)
위 그림에서 본다면 NOT RUNNABLE 에서 자동으로 풀려서 RUNNABLE로 간다.

class ThreadEx extends Thread{
	public void run() {
		for(int i=10; i>0; i--) {
			System.out.println(i);
			try {
				sleep(1000);
			} catch (Exception e) {
				
			}
		}
	}
}

public class UsingThread {
	public static void main(String[] args) throws Exception{
		ThreadEx th1 = new ThreadEx();
		
		th1.start();
		
		String input = JOptionPane.showInputDialog(
				"아무 값이나 입력하세요."
		);
		System.out.println("입력하신 값은 " + input + "입니다.");
	}
}

→ 위의 코드와 비슷하지만 결과가 다르게 나온다.
위에서는 입출력 블로킹이 걸려있지만 지금 코드는 입출력 블로킹이 없이 실행하면 바로 숫자를 셀 수 있다.
→ 다르게 나타나는 이유는 지금 코드에서는 th1의 스레드가 main 스레드와 따로 일을 수행하기 때문이다.
main스레드가 실행 불가 상태가 되어도 th1은 대기열에 있다가 RUNNABLE 상태가 되기에 숫자가 출력되는 것이다.

💙문맥교환(Context Switching)

public class NormalProcess{
	public static void main(String[] args) throws Exception{
		long startTime = System.currentTimeMillis();
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
		System.out.println("소요시간1 : " + (System.currentTimeMillis() - startTime));
		
		for(int i=0; i<300; i++) {
			System.out.print("l");
		}
		System.out.println("소요시간2 : " + (System.currentTimeMillis() - startTime));
	}
}

class ThreadEx extends Thread{
	public void run() {
		for(int i=0; i<300; i++) {
			System.out.print("l");
		}
		System.out.println("소요시간2 : " + (System.currentTimeMillis() - UsingThreadProcess.startTime));
	}
}

public class UsingThreadProcess {
	static long startTime = 0;

	public static void main(String[] args) {
		ThreadEx th1 = new ThreadEx();
		
		startTime = System.currentTimeMillis();
		th1.start();
		for(int i=0; i<300; i++) {
			System.out.print("-");
		}
		System.out.println("소요시간1 : " + (System.currentTimeMillis() - UsingThreadProcess.startTime));

	}
}

→ 2개의 코드를 실행해보면 스레드를 쓰지 않는 게 더 빠른데 왜 우리는 스레드를 쓰는 지 생각해봐야 한다.
이유를 설명할 수 있는 것이 바로 '문맥 교환' 이다.

→ 위 그림을 참고하면, A,B처럼 1개의 main thread만 가지고 있다면 A가 일을 하는 동안 B는 일을 하지 못한다.
그리고 듀얼 thread 가 있는 경우, 교환하면서 실행하는데 실행한 부분까지 저장해줘야 한다.
저장 후 다시 읽어주는 일도 해야하는데, 이와 같이 저장하고 읽는 것을 문맥교환 이라고 한다.
문맥교환을 하면 비용도 많이 들고 시간도 오래 걸리지만 응답성이 좋기에 사용한다.
(빠르게 교대를 해서 동시에 일이 진행된다고 사용자가 느끼기 때문이다.)

💜DaemonThread

DaemonThread : 백그라운드에서 실행되는 thread이다.
사용자가 느끼지 못하는 작업(백그라운드 작업)에 사용한다.

<thread의 종류>
1) 일반 thread
2) DaemonThread

public class DaemonThreadTest {
	public static void main(String[] args) {
		// thread 생성
		Thread t = new Thread() {
			public void run() {
				try {
					System.out.println("MyThread시작");
					// 5초간 멈춤
					Thread.sleep(5000);
					// thread 종료 메세지
					System.out.println("MyThread종료");
				} catch(Exception e) {
					// 무시..
				}
			}
		};
		// 데몬 스레드로 설정..
		t.setDaemon(true);
		// thread 시작
		t.start();
		
		// main 메소드 종료 메세지
		System.out.println("main() 종료");
	}
}

→ 프로그램은 모든 thread 가 다 끝나야 종료가 된다.
프로그램에서 보조작업같은 경우, 사용자가 인지하지 못하지만 계속 동작하고 있을 때도 있다. (= 백그라운드에서 계속 동작하고 있다.)
이로 인해 프로그램이 종료가 안 될수도 있으며, 이런 애들을 DaemonThread로 만들어 주면 된다.
DaemonThread로 만들면 일반 thread가 끝나면 같이 끝나게 된다.
setDaemon()을 통해 DaemonThread로 변경한다.(단, start() 전에 해줘야 한다.)

public class DemonThreadTest2 {
	public static void main(String[] args) {
		Thread t = new Thread() {
			public void run() {
				try {
					System.out.println("MyThread 시작");
					Thread.sleep(100000);
					System.out.println("MyThread 종료");
				} catch (Exception e) {}
			}
		};
	
		t.setDaemon(true);
		t.start();
		Thread t2 = new Thread() {
			@Override
			public void run() {
				try {
					Thread.sleep(3000);
					System.out.println("t2종료");
				} catch(Exception e) {}
			}
		};
		t2.start();
		System.out.println("main() 종료");
	}
}

→ 위 코드를 실행하면, 위와 사진과 같은 결과가 나오는데 t2는 DaemonThread가 아니라서 영향을 받지 않는다.

💜thread 우선순위

class SomeThread extends Thread {
	public SomeThread(String name) {
		super(name);
	}
	@Override
	public void run() {
		String name = this.getName();
		for(int i=0; i<10; i++) {
			System.out.println(name + " is working");
		} 
	}
}

public class RunningTest {
	// main thread는 우선순위가 NORM_PRIORITY(5)이다. 1~10
	public static void main(String[] args) {
		SomeThread t1 = new SomeThread("A");
		SomeThread t2 = new SomeThread("B");
		SomeThread t3 = new SomeThread("C");
		/*
		 *  thread의 우선순위 설정
		 *  thread우선순위 바꾸는거 하지말기.
		 */
		
//		해체 후 실행 결과 비교해 볼것
		t1.setPriority(Thread.MIN_PRIORITY);
		t2.setPriority(Thread.NORM_PRIORITY);
		t3.setPriority(Thread.MAX_PRIORITY);
		
		System.out.println(t1.getPriority());
		System.out.println(t2.getPriority());
		System.out.println(t3.getPriority());
		
		t1.start();
		t2.start();
		t3.start();
	}
}

→ 위 코드를 실행시키면 위 사진과 같은 결과를 볼 수 있다.
결과에서 알 수 있듯이 우선 순위를 부여한다고 해서 무조건 먼저 실행되는 것은 아니다.
단지, 확률만 조금 높여줄 뿐이다.

<우선 순위가 100% 가 아닌 이유>
→ 100%를 주면 우선 순위가 낮은 애들은 기회를 얻지 못할 수도 있다.
그러므로 우선 순위 말고 다른 방식을 주는 것을 추천한다.