스레드(Thread)

<스레드(Thread)>

:일을 처리하는 논리적 단위(로직이나 함수의 실행 단위)

a함수( ) {

}

단일 스레드(우리가 지금가지 해온 방법): a가 시작되고 끝나는 지점

멀티 스레드★★★ : a가 아직 안 끝났는데 또다른 a가 실행(동시에 실행)
-> 완전히 동시에 처리한다기 보다 한 가지를 조금 하고, 다른 함수 조금 실행하고, 또 다른 함수 조금 실행하는 게 멀티 스레드. 이러한 과정이 빠르게 일어나면 동시에 실행하는 것처럼 보인다.

 

단일 스레드가 직렬방식이라면, 그러한 단일 실행단위를 병렬로 놓고 한꺼번에 처리하는 방식이다.
동시접속, 동시성이 조금이라도 필요한 프로그램이라면 반드시 멀티 스레드 작업이 들어간다.

ex. 데이터베이스, 웹사이트, 게임 등등
(= 자원을 공유한다)

 

 

이 부분은 그냥 암기★
1)

-extends Thread(Thread 클래스 상속)

-implements Runnable(Runnable 인터페이스 상속)

 

2)동시성을 갖게 하고 싶은 영역(처리 영역) run()함수에 작성 { }: 오버라이딩

 

3)실행 클래스에서 2)클래스를 import한다.

 

4)인스턴스 생성한다

 

5)run(); 메소드는 호출X(오류는 나지 않지만, 단일 스레드로 실행된다) -> 구현만 할 수 있고 호출 불가능한 메소드
-> 호출할 땐 start() 메소드 대신 호출

 

6)JVM의 thread 스케줄러 영역에 등록된다.

-> run()을 jvm이 알아서 호출 -> 여기부터는 제어권이 jvm으로 넘어간다.(jvm이 알아서 처리한다)
= callback 메소드: 우리가 호출하는 게 아니라 jvm이 알아서 호출하는 메소드

 

 

<예제>

 

 
class ThreadOne implements Runnable { //인터페이스 사용
    private int num;
    private String name;
    public ThreadOne(String a, int b) {
        name = a;
        num = b;
    }
 
    public void run() {
        for(int i = 0; i < num; i++) {
            System.out.println(name + " : " + i)
        }
    }
}
 
public class ThreadTest2 {
    public static void main(String args[]) {
        Thread t1 = new Thread(new ThreadOne(("first"), 1000));
        //Thread -> start()활성화, ThreadOne -> run()활성화                            
        Thread t2 = new Thread(new ThreadOne(("second"), 1000));
        Thread t3 = new Thread(new ThreadOne(("third"), 1000));
        //인터페이스로 start()메소드를 사용하려면 Thread 객체 활성화 필요
        //Thread가 Runnable 인터페이스를 오버라이딩 하고 있기 때문
        // => 하위객체 통해 start()메소드 활성화!
 
        t1.start();
        t2.start();
        t3.start();
    }
}

*Runnable 인터페이스를 사용한 Multi Thread

 

 

 

 

<Sleep>

 

: 멀티 스레드에서 강제로 작업을 쉬도록 하는 명령, 동시성을 갖게 한다.

->작업을 멈추는 순간 그 다음 작업이 이어지는 원리

*sleep(미리세컨드: 1000 = 1초)
-> 스레드는 더 깊은 내용이 많기 때문에 그건 알아서 더 공부해야 한다.

 

 

<예제>

 

 
class RunThread2 extends Thread {
    public RunThread2(String name) {
        super(name);
    }
 
    public void run() {
        for(int i = 1; i <= 10000; i++) {
            if(i % 50 == 0) {
                System.out.println("Thread [" + getName() + "] : " +i);
                try
                    sleep(1); //강제 
                    System.out.println("");
                } catch(Exception e) {}
                //내용이 없다... 이런 식으로 예외처리하면 버그 가능성 높다.
                //차라리 jvm으로 던져버리기
            }
        }
    }
}
 
public class SchedulingTest2 {
    public static void main(String args[]) {
        Thread t[] = new RunThread2[3]; // 4x3=12바이트
 
        t[0] = RunThread2("아");
        t[1] = RunThread2("이");
        t[2] = RunThread2("우");
 
        t[0].start();
        t[1].start();
        t[2].start();
    }
}

"아" "이" "우" 문자가 균등하게 번갈아 가면서 출력된다(마치 동시에 실행되는 것처럼 출력)

 

 

 

<우선순위>

 

: 특정 스레드에 우선권을 부여한다.

-> setPriority(순위: 1~10)

 

Thread.MAX_PRIORITY / NORM_PRIORITY / MIN_R|PRIORITY -> 상수(10 / 5 / 1)
-> 노말 프라이오리티 = System.out.println 정도의 우선순위

확률적으로 10순위 작업이 가장 먼저 끝날 가능성이 크다.(확실성X 가능성의 이야기)

 

 

<예제>

 

 
class RunThread3 extends Thread {
    public RunThread3(String name) {
        super(name);
    }
 
    public void run() {
        for(int i = 1; i <= 10000; i++) {
            if(i % 50 == 0) {
                System.out.println("Thread [" + getName() + "] : " + i);
            }
        }
    }
}
 
public class SchedulingTest3 {
    public static void main(String args[]) {
        Thread[] t = new RunThread3[3];
 
        t[0] = new RunThread("야");
        t[1] = new RunThread("여");
        t[2] = new RunThread("요");
 
        t[0].start();
        t[0].setPriority(10);
        //숫자가 클수록 우선순위 높다
        //우선순위는 동기화와 함께 사용X
 
        t[1].start();    
        t[1].setPriority(5);
 
        t[2].start();
        t[2].setPriority(1);
 
        System.out.println(Thread.MAX_PRIORITY); //상수
        System.out.println(Thread.NORM_PRIORITY);
        System.out.println(Thread.MIN_PRIORITY);
 
        System.out.println(t[0].getPriority());
        System.out.println(t[1].getPriority());
        System.out.println(t[2].getPriority());
    }
}

*대체로 System.out.println 명령이 우선적으로 수행된다.

 

 

 

-Sleep: 서로 섞이게 하는 작업(동시성)
-Priority: 특정 스레드를 우선하는 작업

-> 둘을 동시에 사용할 수 없다! 서로가 서로를 방해할 뿐.