Java - Thread

 
public class Ex {
 
    public static void main(String[] args) {
        /*
         * Thread(쓰레드)
         * - 프로세스 동작의 최소 단위
         * - 하나의 프로세스에서 여러개의 쓰레드가 동작하는 환경을
         *   멀티쓰레딩(Multi Threading) 이라고 한다.
         * - 멀티쓰레딩 사용 시 장점 : CPU 사용률 향상, 응답성 향상, 자원 효율성 증대
         * - 멀티쓰레딩을 구현하는 방법
         *   1. Thread 클래스를 상속받아 run() 메서드를 오버라이딩
         *      => 인스턴스 생성 후 start() 메서드를 호출하여 멀티쓰레딩 실행
         *   2. Runnable 인터페이스를 구현하여 run() 메서드를 오버라이딩
         *      => start() 메서드가 존재하지 않으므로
         *         Thread 클래스 생성자에 Runnable 인터페이스 구현 객체를 전달한 뒤
         *         Thread 클래스를 통해 start() 메서드를 대신 호출하여 멀티쓰레딩 실행
         * - run() 메서드는 내부적으로 JVM 에 의해 호출되어질 메서드
         *   (사용자가 호출할 메서드는 start() 메서드로 메서드 내에서 run() 메서드 호출됨)
         *  
         */
        
//        NoThread nt1 = new NoThread("★A작업★", 1000000);
//        NoThread nt2 = new NoThread("※B작업※", 500000);
//        NoThread nt3 = new NoThread("◎C작업◎", 1000000);
//        
//        nt1.run();
//        nt2.run(); // A작업(nt1) 실행이 끝난 후 실행됨
//        nt3.run(); // B작업(nt2) 실행이 끝난 후 실행됨
        
        System.out.println("------------------------------");
        
        // 1. Thread 클래스를 상속받아 구현했을 때
//        MyThread mt1 = new MyThread("★A작업★", 1000000);
//        MyThread mt2 = new MyThread("※B작업※", 500000);
//        MyThread mt3 = new MyThread("◎C작업◎", 1000000);
//        
        // run() 메서드에 코드가 구현되어 있지만 호출은 start() 메서드 필수!
        // 만약, run() 메서드를 직접 호출하는 경우 멀티쓰레딩이 아닌 단일쓰레딩으로 실행됨
////        mt1.run();
////        mt2.run(); 
////        mt3.run(); 
//        
//        mt1.start();
//        mt2.start(); 
//        mt3.start(); 
        
        System.out.println("------------------------------");
        
        YourThread yt1 = new YourThread("★A작업★", 1000000);
        YourThread yt2 = new YourThread("※B작업※", 500000);
        YourThread yt3 = new YourThread("◎C작업◎", 1000000);
        
        // run() 메서드 호출 시 멀티쓰레딩으로 동작하지 않는다!
//        yt1.run();
//        yt2.run();
//        yt3.run();
        
        // Runnable 인터페이스 내에 start() 메서드가 없을뿐더러
        // 있다하더라도 추상메서드이므로 호출이 불가능
//        yt1.start(); // 존재하지 않는 메서드
//        yt2.start(); // 존재하지 않는 메서드
//        yt3.start(); // 존재하지 않는 메서드
        
        // Thread 클래스의 인스턴스를 생성하고, 
        // 생성자에 Runnable 을 구현한 서브클래스의 인스턴스를 전달하여
        // Thread 인스턴스에서 대신 start() 메서드를 호출해야한다!
//        Thread t1 = new Thread(yt1); // 생성자에 Runnable 구현한 인스턴스를 전달 가능
//        Thread t2 = new Thread(yt2); // 생성자에 Runnable 구현한 인스턴스를 전달 가능
//        Thread t3 = new Thread(yt3); // 생성자에 Runnable 구현한 인스턴스를 전달 가능
        
        // ----------- Runnable -> Thread 의 코드를 줄이는 방법 ------------
//        Thread t1 = new Thread(new YourThread("★A작업★", 1000000));
//        Thread t2 = new Thread(new YourThread("※B작업※", 500000));
//        Thread t3 = new Thread(new YourThread("◎C작업◎", 1000000));
        
        // => Thread 클래스의 start() 메서드를 호출
//        t1.start();
//        t2.start();
//        t3.start();
        
        // Thread 클래스의 변수 선언도 생략할 경우
        new Thread(new YourThread("★A작업★", 1000000)).start();
        new Thread(new YourThread("※B작업※", 500000)).start();
        new Thread(new YourThread("◎C작업◎", 1000000)).start();
    }
 
}
 
// 싱글(단일) 쓰레드 구현
class NoThread {
    String name;
    int count;
    
    public NoThread(String name, int count) {
        super();
        this.name = name;
        this.count = count;
    }
    
    public void run() {
        for(int i = 1; i <= count; i++) {
            System.out.println(name + " : " + i);
        }
    }
    
}
 
// 멀티 쓰레드 구현
// 1. Thread 클래스를 상속받는 서브클래스를 정의하는 방법
class MyThread extends Thread {
    String name;
    int count;
    
    public MyThread(String name, int count) {
        super();
        this.name = name;
        this.count = count;
    }
 
    // Thread 클래스를 상속받은 뒤 반드시 run() 메서드 오버라이딩 필수!
    @Override
    public void run() {
        // run() 메서드 내부에 멀티쓰레딩으로 처리할 코드를 기술
        // => 여기에 기술되는 코드들은 (다른 작업과 별개로 동시에 수행됨)
        for(int i = 1; i <= count; i++) {
            System.out.println(name + " : " + i);
        }
    }
    
}
 
// 2. Runnable 인터페이스를 구현하는 서브클래스를 정의하는 방법
class A {}
// 기존에 다른 클래스를 상속받은 상태에서는 Thread 클래스를 상속받을 수 없으므로
// Runnable 인터페이스를 상속받아 run() 메서드를 오버라이딩 한다!
class YourThread extends A implements Runnable {
    String name;
    int count;
    
    public YourThread(String name, int count) {
        super();
        this.name = name;
        this.count = count;
    }
    
    // Runnable 인터페이스를 구현한 뒤 반드시 run() 메서드 오버라이딩 필수!
    @Override
    public void run() {
        // run() 메서드 내부에 멀티쓰레딩으로 처리할 코드를 기술
        // => 여기에 기술되는 코드들은 (다른 작업과 별개로 동시에 수행됨)
        for(int i = 1; i <= count; i++) {
            System.out.println(name + " : " + i);
        }
    }
    
}
 
import java.time.LocalTime;
 
public class Ex2 {
 
    public static void main(String[] args) {
        
        /*
         * 쓰레드 제어
         * 현재 실행중인 쓰레드에 대한 각종 제어 수행 가능
         * sleep() 메서드를 호출하면 현재 실행중인 쓰레드를 대기폴에서 재움
         * 파라미터로 밀리초 단위 시간 설정 가능하며, 시간이 만료되거나
         * interrupt() 메서드가 호출되면 대기폴에서 Runnable 로 이동
         * 우선순위가 낮은 쓰레드가 실행되지 못하는 상태(기아 상태)에 빠지는 것을
         * 방지하기 위해 모든 쓰레드들을 일정 시간동안 재움(sleep)
         * 
         * 
         * 기본 사용 문법
         * Thread.sleep(밀리초)// try~catch 필요
         */
//        Thread t=Thread.currentThread();//현재 쓰레드 객체 가져오기
        
//        System.out.println("현재 쓰레드명 : "+Thread.currentThread().getName());
        
        Timer t=new Timer("시계1");
        t.start();
        
//        for(int sec=0;sec<=59;sec++) {
//            //현재 쓰레드를 1초 동안 재움으로써 타이머 효과부여
//            try {
//                Thread.sleep(1000);
//            } catch (InterruptedException e) {
//                // TODO Auto-generated catch block
//                e.printStackTrace();
//            }
////            System.out.println(sec+"초");
//            System.out.println(LocalTime.now());
//        }
        
        
        
        
    }
 
}
 
class Timer extends Thread{
    
    public Timer(String threadName) {
        //슈퍼클래스인 Thread 클래스의 생성자를 호출하여 문자열 전달 시
        //해당 쓰레드의 이름 초기화 가능->getName() 으로 가져올 수 있다.
        super(threadName);
    }
 
    @Override
    public void run() {
        for(int sec=0;sec<=59;sec++) {
            //현재 쓰레드를 1초 동안 재움으로써 타이머 효과부여
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
//            System.out.println(sec+"초");
//            System.out.println(LocalTime.now());
            System.out.println(getName()+" : "+LocalTime.now());
        }
    }
    
}
 
 
 
public class test {
 
    public static void main(String[] args) {
        //GugudanThread 인스턴스 5개 생성
        //생성자에 각각의 구구단의 단 전달(2~9 사이의 중복되지 않는 값)하여 출력
        GugudanThread g=new GugudanThread(2);
        GugudanThread g1=new GugudanThread(6);
        GugudanThread g2=new GugudanThread(9);
        GugudanThread g3=new GugudanThread(8);
        GugudanThread g4=new GugudanThread(5);
        GugudanThread g5=new GugudanThread(7);
        
        g.start();
        g1.start();
        g2.start();
        g3.start();
        g4.start();
        g5.start();
        
        for(int i=1;i<=1000;i++) {
            System.out.println("--------------");
        }
        
        
        
    }
 
}
 
//Thread 클래스를 상속받는 GugudanThread 클래스 정의
//생성자에 int형 변수(dan) 전달받아서 멤버변수에 초기화
//run()메서드 오버라이딩 후 멤버변수 dan 에 해당하는 구구단을 100번 출력
 
class GugudanThread extends Thread{
    int dan;
 
    public GugudanThread(int dan) {
        super();
        this.dan = dan;
    }
 
    @Override
    public void run() {
        for(int j=1; j<=100;j++) {
            
            for(int i=1; i<=9;i++) {
                System.out.println(dan+"X"+i+" = "+(dan*i));
            }
        }
    }
    
}
 
 

 

Thread에 대해 알아보았는데 흔히들 알고 있는 Multi Threading의 그 Thread이다.

컴퓨터는 한번에 하나의 일 밖에 하지 못하는 정직한 친구이기 때문에 시간을 나누어 순차적으로 여러 작업을 동시에 하는데 이 기능이 Thread이고 이 기능 때문에 사용자 입장에서는 컴퓨터가 여러 일을 한 번에 수행하는지 알고 있기도 하다.

Thread를 사용하기 위해서 클래스를 설정할 때 Thread 클래스를 상속받게 한후 run() 메서드를 오버 라이딩 꼭 해야 하고

만약 상속받는 클래스가 있는 클래스에 Thread를 설정하기 위해서는 Runnable 인터페이스를 구현해서 사용하면 된다.

Runnable을 구현해도 run() 메서드는 꼭 오버 라이딩해줘야 한다.

그리고 Thread 구현 중에 잠시 텀을 주기 위해서 Thread.sleep()을 사용하는데 sleep()의 파라미터 값이 1/1000밀리 초 이기 때문에 1초의 텀을 주기 위해서는 Thread.sleep(1000); 을 해주면 1초의 텀을 가진다. 이게 전자시계의 구동방식이다.