쓰레드

[ 프로세스와 쓰레드 ] p

1) 쓰레드는 프로세스와 연관지어 나온다.

2) 프로세스 : 실행 중인 프로그램

- Foregroud Process

- Background Process

3) 쓰레드

- 응용프로그램 내에서 실행되는 최소 실행 단위

- 프로레스 자원을 이용해서 실제로 작업을 수행하는 것

- 데이터를 공유해서 작업 => 동기화 작업과 연관

EX) 웹 브라우져

- 특정 사이트에 접속하여 홈페이지를 보여주는 프로그램

1) 먼저 접속을 시켜주는 쓰레드가 존재

2) 홈페이지를 보여주는 쓰레드

3) 동영상, 문자, 데이터 등을 보여주는 쓰레드

=> 하나의 프로그램에는 여러개의 쓰레드가 존재할 수 있다.

[ 싱글 쓰레드와 멀티 쓰레드 ]

1) 싱글 쓰레드

2) 멀티 쓰레드

- 쓰레드가 여러개가 작동

- CPU 사용률을 향상

- 자원을 보다 효율적으로 사용

- 사용자에 대한 응답성이 향상 => 메모리를 적게 사용(메모리 절약)

- 작업이 분리되어 코드가 간결

* 웹프로그래밍

- JSP(홈페이지 작성)

- 서버 필요(톰캣서버) : 다양한 요청을 처리=>쓰레드 단위로 요청을 처리

---

[ 쓰레드의 작성 순서 ]

1) Thread 클래스를 상속받는다.

2) run() 메서드를 작성 (쓰레드의 기능을 작성한다.)

3) 쓰레드 객체를 생성

4) start() 메서드를 호출한다.

*상속을 사용하는 목적

- 코드 절약, 개발단축

- 기능을 구현하기 위해 (Thread 클래스)

1) Thread 클래스를 상속받으면 쓰레드 기능을 사용 할 수 있다.

- 오버라이딩을 하기 위해 상속을 받는다.

*) run() :

- 실시간으로 데이터를 보여주는 기능

- 데이터를 출력, 계산, 저장,,,

- Thread클래스에 있음

*) strat()

- 내부적으로 run()실행

EX) Threas 클래스를 상속받는 방법 

package j0616;

// 1.Thread 클래스를 상속받으면 쓰레드 기능을 사용할 수 있다.

public class MultiThread extends Thread {

        // 쓰레드 이름 : 생성자

        public MultiThread(String s) {

                //this.setName(s); //쓰레드의 이름을 부여<-> getName();

                super(s);

        }

        @Override // Thread 클래스가 가지고 있음, 실시간으로 데이터를 보여주는 기능

        public void run() {

                // TODO Auto-generated method stub

                //소문자를 출력시키는 기능

                for(char i='a';i<='z';i++) {

                        try {

                        Thread.sleep(500); // 호출 속도조절, InterruptedException 예외처리

                        //sleep(1000) = 1초동안 정지

                        System.out.println(i);

                        System.out.println("쓰레드의 이름 : "+this.getName()); // this=mt

                        }catch(Exception e) {e.printStackTrace();}

                }

        }

        public static void main(String[] args) {

                // TODO Auto-generated method stub

                MultiThread mt=new MultiThread("임시"); // 다른 생성자가 있을 경우 기본 생성자가 만들어지지 않는다.

                mt.start(); // 내부적으로 run() 메서드 호출

        }

}

[ Runnable 인터페이스를 상속받는 방법 ]

- Thread 클래스를 상속 받을 수 없는 경우 

1) Raunnable 인터페이스를 상속받는 자식 클래스를 작성

2) Thread 클래스의 객체를 생성

3) Thread 클래스의 객체를 생성할 때 생성자의 인수로서 Runnable 인터페이스를 상속받은 자식클래스의 객체를 매개변수로 넘겨준다

package j0616;

import java.io.BufferedReader;

import java.io.*;

public class MultiThread2 {

        public static void main(String[] args) throws Exception {

                // TODO Auto-generated method stub

                // 1) Runnable 인터페이스를 상속받은 자식클래스 객체생성

                System.out.println("실행시킬 단을 입력하세요");

                BufferedReader br=new BufferedReader

                                (new InputStreamReader(System.in));

                int dan=Integer.parseInt(br.readLine());

                GooGoo go=new GooGoo(dan);

                // 2) Thread 클래스 객체 생성 -> 생성자 인수로서 Runnable 인터페이스를 상속받은 자식클래스를 넣어줌

                Thread t=new Thread(go);

                // 3) Thread 클래스 객채를 호출

                t.start();

        }

}

// 2) 구구단을 출력 : Rannable 인터페이스를 상속

class GooGoo implements Runnable{

        private int dan;

        public GooGoo(int dan) {

                this.dan=dan;

        }

        // 인터페이스한 추상 메서드 오버라이딩

        @Override

        public void run() {

                // TODO Auto-generated method stub

                for(int i=1; i<=9; i++) {

                        try {

                                Thread.sleep(500);

                                System.out.println(dan+"단 : "+dan+"*"+i+"="+(dan+i));

                        }catch(Exception e) {System.out.println(e);}

                } //for

        }

}

[ 쓰레드의 우선순위 ] p.738

- 한개 이상의 쓰레드를 가지고 있을 경우 어느 특정한 쓰레드를 우선적으로 실행...

- 쓰레드는 우선순위(priority)라는 속성(멤버변수)을 가지고 있다

- 이 우선순위의 값에 따라 쓰레드가 얻는 실행시간이 달라진다

- 1~5~10 => 멤버변수로 제공, 1(최소우선순위), 5(보통우선숭위), 10(최대우선순위)

package j0616;

import java.io.BufferedReader;

import java.io.*;

public class MultiThread2 {

        public static void main(String[] args) throws Exception {

                // TODO Auto-generated method stub

                // 1) Runnable 인터페이스를 상속받은 자식클래스 객체생성

                GooGoo go=new GooGoo(4);

                // 2) Thread 클래스 객체 생성 -> 생성자 인수로서 Runnable 인터페이스를 상속받은 자식클래스를 넣어줌

                Thread t=new Thread(go);

                // 3) Thread 클래스 객채를 호출

                //t.start();

                // 2번째 Thread 생성 실행

                PrintThread pt=new PrintThread();

                // 우선순위를 정해준다 : setPriority(우선순위숫자);

                t.setPriority(10);

                pt.setPriority(Thread.MIN_PRIORITY); // 1

                t.start(); pt.start();

        }

}

// 2) 구구단을 출력 : Rannable 인터페이스를 상속

class GooGoo implements Runnable{

        private int dan;

        public GooGoo(int dan) {

                this.dan=dan;

        }

        // 인터페이스한 추상 메서드 오버라이딩

        @Override

        public void run() {

                // TODO Auto-generated method stub

                for(int i=1; i<=9; i++) {

                        try {

                                Thread.sleep(500);

                                System.out.println(dan+"단 : "+dan+"*"+i+"="+(dan+i));

                        }catch(Exception e) {System.out.println(e);}

                } //for

        }

}

// 1) 임의의 숫자를 속도 조절하면서 출력

class PrintThread extends Thread{

        @Override

        public void run() {

                // TODO Auto-generated method stub

                for(int i=1;i<=9;i++) {

                        try {

                                //임의의 숫자를 만드는 방법(난수 생성) : 0~0.99999

                                //Math.random()

                                long sleeptime=(int)(Math.random()*500+1);

                                Thread.sleep(sleeptime);

                                System.out.println("i="+i);

                        }catch(Exception e) {System.out.println(e);}

                }//for

        }

}

[ strat()와 run()의 차이점 ]

1) strat()

- main()을 먼저 실행하고 start()을 실행

- 기존 main쓰레드를 유지가 되면서 다른 쓰레드를 가동

2) run()

- main()이 run()을 만나면 멈추고 run()을 실행

- 기존의 main 쓰레드가 멈춘 상태에서 다른 쓰레드를 가동

- 안정성의 문제가 발생할 수 있음

- 성능에 영향을 미친다(secode coding)

=> 반드시 strat()를 쓴다

package j0616;

// strat()와 run()의 차이점

public class MyThread implements Runnable{

        @Override

        public void run() {

                // TODO Auto-generated method stub

                while(true) {

                        System.out.println("is Runnig");

                        try {

                                Thread.sleep(1000); // 1초

                        }catch(Exception e) {System.out.println(e);}

                }//while

        }

        public static void main(String[] args) {

                // TODO Auto-generated method stub

                MyThread my=new MyThread();

                Thread t=new Thread(my);

                //t.start(); // main() 실행 후 start() 실행

                t.run(); // maim()이 run()을 만나면 멈춰버리고 run()을 실행

                System.out.println("MainThread Terminated!");

        }

}