[JAVA] 쓰레드(Thread)의 기초 및 이론, 활용, 응용, 예제

관련글

2012/03/31 - [Dev. 안드로이드/참고소스] - Thread의 종료에 대한 예제 소스

2012/09/03 - [Dev. 640시간 뭉개기/강의내용정리] - [자바] 27일차 - 쓰레드(Thread), JDBC

2012/09/03 - [Dev. 자바/API 및 이론] - [JAVA API] java.lang.Thread

2012/09/04 - [기타] - windows 작업관리자에서 쓰레드(Thread) 수 확인하기

 

 

쓰레드(Thread)란?

한 프로그램이 하나 이상의 독립적인 서브태스크(subtask)로 분리되어 실행될 때 각 서브 태스크를 쓰레드라 한다.

각 쓰레드는 별개로 실행하면서 CPU를 공동으로 사용한다. 이렇게 하나의 프로세스에서는 동시에 여러 쓰레드가 실행될 수 있다.

 

 

 

쓰레드(Thread)의 Life-Cycle

 

 

쓰레드(Thread)의 생성 방법

1. Thread 클래스로부터 상속받기

public class HelloThread extends Thread {

       

    public void run() {

        System.out.println("Hello from a thread!");

    }

 

    public static void main(String args[]) {

        (new HelloThread()).start();

    }

}

 

2. Runnable 인터페이스로 Thread 만들기

public class HelloRunnable implements Runnable {

 

    public void run() {

        System.out.println("Hello from a thread!");

    }

 

    public static void main(String args[]) {

        (new Thread(new HelloRunnable())).start();

    }

}

 

쓰레드(Thread) 관련 용어 설명

 

join : 쓰레드가 죽을때까지 기다린다.

package th;

 

import java.util.*;

 

public class TestThread2 implements Runnable {

 

    static Vector<String> rankList = new Vector<>();  // 멀티쓰레드 환경에서는 Vector 사용

   

    @Override

    public void run() {

        String name = Thread.currentThread().getName();

        Random r = new Random();

       

        for (int i = 0; i < 11; i++) {

            try {

                Thread.sleep(r.nextInt(3000));

            } catch (InterruptedException e) {

               

                e.printStackTrace();

            }

            System.out.println(name + "마가 " + (i*100) + "m 지점을 통과하였습니다.");

               

        }//end for i

        rankList.add(name);

    }

 

    public static void main(String[] args) {

        String name = Thread.currentThread().getName(); // 쓰레드의 이름을 가져온다

        System.out.println(name + "이 main을 실행중");

        TestThread2 target = new TestThread2();

        Thread th1 = new Thread(target, "털광필");

        Thread th2 = new Thread(target, "몽골용단");

        Thread th3 = new Thread(target, "풉시크기남");

        Thread th4 = new Thread(target, "자선취미영환");

        Thread th5 = new Thread(target, "주원?병준");

       

        th1.start();

        th2.start();

        th3.start();

        th4.start();

        th5.start();

       

        try {

            th1.join();     // main쓰레드가 join이 호출되는 쓰레드가 끝날때까지 기다린다.

            th2.join();

            th3.join();

            th4.join();

            th5.join();

        } catch (InterruptedException e) {

           

            e.printStackTrace();

        }

       

        System.out.println("!!경주 끝!!");

        for(int i=0; i<rankList.size(); i++) {

            System.out.println(rankList.get(i)+"마(馬)가 "+(i+1)+"등을 하였습니다.");

        }

    }

 

}

 

 

priority : 우선순위

실행 전에 setPriority로 우선순위를 부여한다. ( 1 ~ 10 )

package th;

 

public class TestThread3 {

 

    Runnable target = new Runnable() {

       

        @Override

        public void run() {

            String name = Thread.currentThread().getName();

           

            for (int i = 0; i < 1000; i++) {

//                Thread.yield();        // 양보

                /*try {

                    Thread.sleep(1000);

                } catch (InterruptedException e) {

                   

                    e.printStackTrace();

                }*/

                System.out.println(name + " : " + i);

            }

        }

           

    };

   

   

    public void excute() {

        Thread th1 = new Thread(target);

        Thread th2 = new Thread(target);

        Thread th3 = new Thread(target);

        Thread th4 = new Thread(target);

       

        // 실행 전에 우선순위를 부여한다.

        th1.setPriority(Thread.MAX_PRIORITY);   // 10

        th2.setPriority(6);

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

 

        // 실행

        th1.start();

        th2.start();

        th3.start();

        th4.start();

    }

   

    public static void main(String[] args) {

   

        new TestThread3().excute();

       

       

    }

 

   

 

}

 

 

 

deadlock : 계속 응답대기상태 (화장실에 들어가서 문잠그고 죽어버린것!!!! 비유하자면..ㅎ)

Interrupt : 응답이 없거나 wait 상태에 있는 경우 빠져나오게 한다.

package th;

 

public class TestThread4 {

 

    private class Target implements Runnable {

 

        int x;

        int y;

       

        @Override

        public void run() {

            for (int i = 0; i < 10000; i++) {

                synchronized (this) {          // 인수 : 대상 객체

                    add();

                    System.out.println("x : " + x + ", y : " + y);

                    //  Thread.currentThread().suspend();

                    // Deadlock 이 발생하기 때문에 쓰지 말도록 한다.

                    // Deadlock : 화장실에 들어가서 문을 잠그고 죽어버린것!!!!(응답없음...)

                    try {

                        Thread.sleep(10000);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                        System.out.println("쓰레드가 Interrupt 됨");

                    }

                    minus();

                }

            }

        }

 

        private synchronized void minus() {     //

            x--;

            y--;

        }

 

        private synchronized void add() {

            x++;

            y++;

        }

       

    }

    public static void main(String[] args) {

 

        new TestThread4().excute();

    }

 

    public void excute() {

        Target target = new Target();

        Thread th1 = new Thread(target);

//        Thread th2 = new Thread(target);

        th1.start();

//        th2.start();

        try {

            Thread.sleep(5000);

        } catch (InterruptedException e) {

           

            e.printStackTrace();

        }

        th1.interrupt();

    }

}

 

 

 

wait : 대기

wait 상태가 되면 현재 존재하는 곳의 synchronized 만 유효하고 다른곳의 동기는 풀린다
wait 는 notify 로 깨운다

 

notify : 자고있는 쓰레드 중 하나를 무작위로 깨운다. 지정하여 깨우는것 안됨

notifyAll : 자고있는 모든 쓰레드를 깨운다.

synchronized : 동기화

한번에 하나의 쓰레드만 수행할 수 있도록 한다.

객체에 대해서 모니터를 가지게 되고 락을 걸게 된다

 

Execute.java

 

package th.wait;

 

public class Execute

{

        public static void main(String[] args)

        {

               Drop drop = new Drop();

               Producer p = new Producer(drop);

               Consumer c = new Consumer(drop);

               Thread th1 = new Thread(p);

               Thread th2 = new Thread(c);

 

               th1.start();

               th2.start();

        }

}

 

---

Consumer.java

 

package th.wait;

 

public class Consumer implements Runnable {

        private Drop drop;

 

        public Consumer(Drop drop) {

               this.drop = drop;

        }

 

        public void run() {

               while(true) {

                       try {

                              Thread.sleep(8000);

                       }catch(Exception e) {}

 

                       String message = drop.take();

 

                       if (message.equals("end")) break;

 

                       System.out.println("product : " + message);

               }

        }

}

 

---

Drop.java

 

package th.wait;

 

public class Drop

{

        private String message;

 

        private boolean isEmpty = true;

 

        int i = 0;

 

        public synchronized String take() {

               while(isEmpty) {

                       try {

                              wait();

                       }catch(InterruptedException ie) {}

               }

/*

               deadlock 설명 위한 소스

               if(i == 1)          

                       Thread.currentThread().destroy();

 

               i++;

*/

 

               isEmpty = true;

 

               notifyAll();

 

               return message;

        }

 

        public synchronized void put(String message) {

               while(!isEmpty) {

                       try {

                              wait();

                       }catch(Exception e) {}

               }

              

               isEmpty = false;

 

               this.message = message;

 

               notifyAll();

        }

}

---

Producer.java

 

package th.wait;

 

public class Producer implements Runnable {

        private Drop drop;

 

        public Producer(Drop drop) {

               this.drop = drop;

        }

 

        public void run() {

               String[] product = {

                       "털광필",

                       "주원?병준",

                       "sick기남",

                       "몽골용단",

                       "반사은석"

               };

 

               for(int i=0; i<product.length; i++) {

                       drop.put(product[i]);

                       try {

                              Thread.sleep(5000);

                       }catch(Exception e) {}

               }

 

               drop.put("end");

        }

}

 

 

Daemon Thread : 메인 쓰레드가 끝날때 운명을 같이 한다. (강제종료)
                        원래는 쓰레드가 끝날때까지 메인 쓰레드는 종료되지 않는다.

package th;

 

public class TestThread5 implements Runnable {

 

    @Override

    public void run() {

        while (true) {

            System.out.println("데몬!데몬!데몬!");

        }

    }

 

    public static void main(String[] args) {

        // Daemon Thread : 프로그램 종료시 쓰레드까지 종료함

        new TestThread5().execute();

        System.out.println("main끝");

    }

 

    public void execute() {

        Thread th = new Thread(this);

        th.setDaemon(true);

        th.start();

        try {

            Thread.sleep(10000);

        } catch (InterruptedException e) {

           

            e.printStackTrace();

        }

    }

 

}

 

 

 

 

 

* 멀티쓰레딩 시 프로그램의 실행 속도에 문제가 있다면 다음 사항을 확인해야 한다.

1. sleep(), yield(), wait() 메소드를 충분한 만큼 사용하고 있는가?

2. sleep() 메소드의 인자로 주는 대기 시간을 충분히 길게 지정하였는가?

3. 너무 많은 쓰레드를 실행시키는 것은 아닌가?