210423_3~4(멀티스레드)

멀티스레드

 

1. 스레드 Thread : 어떤 로직이나 함수의 실행 단위.

 

a(){ }

                              (cpu자원)

a( ) 3번 호출  |---a()---|---a()---|---a()---|   ===> 단일스레드 - 지금까지 사용법

                                                                각각의 함수가 자원을 독점

                   (cpu자원)

a( ) 3번 호출  |---a()---|

                      |---a()---|

                         |---a()---| 

                          --   동시성을 갖고 실행되는구간===> 멀티스레드(동시에 실행되는 것처럼 보임)

                                                                             자원을 공유해서 사용한다

 

멀티스레드의 장점 

[웹서버 - 하나의 클라이언트 처리시간 1초라고 가정]

  동시에 1000명이 접속했다. 1000번째 사람의 앞에 999명의 즉999초 동안 기다려야 자신의 처리가 돌아온다

  그런데, 멀티스레드가 되면, 웹서버가 자원을 돌아가면서 모든 클라이언트들에게 처리를 조금씩 돌아가면서

  하게되므로 훨씬 빠른속도로 자신의 처리를 할 수가 있다.

 

돈이 되는 프로그램은 다 멀티다. 게임서버, db서버, 웹서버, 채팅 서버 ...~

---

적용방법

 

 

Runnable 인터페이스 적용하거나

   |

Thread 클래스를 상속받아서  // Thread클래스는 Runnable을 구현한 구현 클래스이다.

   |

MyThread { // 다중상속으로 Thread상속을 받을수없을때 Runnable 인터페이스를 적용한다.

  ↓

run( ) { 

멀티로 구현하고자 하는 로직이나 함수를 run 메서드로 감싼다

    }

}

 

 

기억!

Runnable	Thread
run()	run(), start()가 있다.

결론 : 실행하려면 start() 가 포함하는 Thread 객체(인스턴스)를 만들어야한다

 

호출

MyThread mt = new MyThread ();

mt.run() ;  <=== 호출불가. run()은 구현만 할 수 있고, 호출이 불가하다. 그래도 호출하면 단일스레드로 작동됨(주의

mt.start() ; <=== start() 라는 메서드로 호출한다.

 

원리

  start( ) <==== jvm에 요청 등록 === >run() 호출

  run( ) 은 jvm에 의해서 호출되므로 callback method라고 한다.

package chapter16;

//스레드가 없는경우
class GenClass {
	private int num; //필드1
	private String name; //필드2

	public GenClass(String a, int b) { //생성자
		name = a;
		num = b;
	}

	public void start() { //메서드1
		for (int i = 0; i < num; i++) //로직
			System.out.println(name + "." + i);
	}

}

public class NonThread {

	public static void main(String[] args) {
		GenClass t1 = new GenClass("first", 5);
		GenClass t2 = new GenClass("second", 5);
		GenClass t3 = new GenClass("third", 5);

		t1.start(); //단일스레드  jvm start()와 관련x
		t2.start();
		t3.start();
	}

}
//first.0
//first.1
//first.2
//first.3
//first.4
//second.0
//second.1
//second.2
//second.3
//second.4
//third.0
//third.1
//third.2
//third.3
//third.4

package chapter16;

//멀티스레드 적용
class MyThread extends Thread { //스레드상속
	private int num;
	private String name;

	public MyThread(String a, int b) { //생성자
		name = a;
		num = b;
	}

	public void run() {   // 멀티스레드구현 run()메서드
		for (int i = 0; i < num; i++)
			System.out.println(name + ":" + i);
	}
}

public class ThreadTest1 {

	public static void main(String[] args) {
		MyThread t1 = new MyThread("first", 1000); //인스턴스1 
		MyThread t2 = new MyThread("second", 1000); //인스턴스2
		MyThread t3 = new MyThread("third", 1000); //인스턴스3

		t1.start(); // jvm start
		t2.start(); // 단 한번이라도 처리가 섞이면 멀티스레드이다
		t3.start();
	}

}
//second:0
//third:0
//first:0
//third:1
//second:1
//third:2
//first:1
//third:3
//second:2
//third:4
//....~~

 

package chapter16;

//Runnable 인터페이스를 통한 멀티스레드
class ThreadOne implements Runnable { // Runnable 인터페이스상속//ThreadOne가 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 TreadTest2 {

	public static void main(String[] args) {
		Thread t1 = new Thread(new ThreadOne(("first"), 1000));
		// Thread는 Runnable을 구현한 클래스이다
      	 	// Runnable로 만들면 하위객체를 호출하지못하기때문에 형변환도해야한다
		Thread t2 = new Thread(new ThreadOne(("second"), 1000));
		Thread t3 = new Thread(new ThreadOne(("third"), 1000));
        //생성자안의 파라미터에 Runnable의 인자(상속받은 ThreadOne)를 넣어서 사용하기때문
     	// =new Tread(new 러너블타겟()) ->new 러너블타겟()이 인자를 두개갖고있기때문에()가 또들어간것



		t1.start();
		t2.start();
		t3.start();
	}

}

---

동시성 구간을 크게하기

앞의 사실에서 알수있듯이, 첫 스레드에서 잠시 쉬어갈때 다른 스레드가 시작된다.

그렇다면, 강제로 쉬게 하면 더 동시성 구간이 커지지 않을까?

 

그래서 sleep(ms);메서드 ms는 1/1000초 동안 쉬도록 하면 골고루 섞인다.

package chapter16;

//동기화없는 경우
class RunThread extends Thread {

	public RunThread(String name) {
		super(name); //Thread의 String을 인자로 갖는 생성자
	}

	public void run() {
		for (int i = 1; i <= 500; i++) {
			if (i % 50 == 0)
				System.out.println("Thread[" + getName() + "]:" + i);
			                                 //getName은 상속받은 Thread에서 온것

		}
	}
}

public class SchedulingTest1 {

	public static void main(String[] args) {
		Thread[] t = new RunThread[2]; //스레드 배열

		t[0] = new RunThread("ONE");
		t[1] = new RunThread("TWO");

		t[0].start();
		t[1].start();

	}

}
//Thread[TWO]:50
//Thread[TWO]:100
//Thread[TWO]:150
//Thread[ONE]:50
//Thread[ONE]:100
//Thread[TWO]:200
//Thread[ONE]:150
//Thread[ONE]:200
//Thread[TWO]:250
//Thread[ONE]:250
//Thread[TWO]:300
//...~ 동시성이거의없다

package chapter16;

//동기화를 처리한경우
class RunThread2 extends Thread {
	public RunThread2(String name) {
		super(name);
	}

	public void run() {
		for (int i = 1; i <= 500; i++) {
			if (i % 50 == 0) {
				System.out.println("Thread[" + getName() + "] :" + i);
				try {
					sleep(1); // 1/1000초에 한번 쉼 //동시성을 크게하기위함
					System.out.println("");
				} catch (Exception e) {
				}
			}
		}
	}
}

public class SchedulingTest2 {

	public static void main(String[] args) {
		Thread[] t = new RunThread2[3];

		t[0] = new RunThread2("☆");
		t[1] = new RunThread2("★");
		t[2] = new RunThread2("◆");

		t[0].start();
		t[1].start();
		t[2].start();
	}

}
//Thread[★] :50
//Thread[☆] :50
//Thread[◆] :50
//				//sleep발생구간
//
//Thread[☆] :100
//
//Thread[★] :100
//Thread[◆] :100
//Thread[★] :150
//
//
//Thread[◆] :150
//Thread[☆] :150
//
//
//
//Thread[◆] :200
//Thread[★] :200
//Thread[☆] :200
//
//
//Thread[★] :250
//
//Thread[◆] :250
//Thread[☆] :250
//...~