Thread (쓰레드 ) 우선권을 위한 Blocking Method -2

 

보통 입출력 (I/O)의 우선권이 가장 높다.

Boocking 이란 동작중이던 쓰레드를 잠시 멈추는 것이고,

강제로 멈추게도 가능하다.

강제로 멈추는 이유는 Thread는 기본적으로 우선권 방식으로 실행되기때무넹 우선권이 낮은 경우 대기만 타고 있는 경우가 있다.

이런경우를 Starvationg (기아상태) 라고 하는데 이 경우에 사용하는 메소드가 Sleep() 이다.

 

Thread.sleep(1/1000초);

형식으로 사용을 하고 시간 만큼 blocking 되는 것.

 

실행할때 마다 결과는 달라지지만 ( 왜냐면 random 함수를 써서 blocking 시간을 매번 다르게 했기 때문에)

실행결과를 보면 대기 시간이 각각 설정이 되고, 대기 시간이 짧은 것부터 실행되는 것을 알 수 있다.

 

consol 결과 ---------------------

4단은 462만큼 sleep..
7단은 366만큼 sleep..
5단은 430만큼 sleep..
6단은 200만큼 sleep..
3단은 320만큼 sleep..

main 종료
2단은 230만큼 sleep..
8단은 192만큼 sleep..
9단은 8만큼 sleep..

9 단 : 9 * 1 = 9
9 단 : 9 * 2 = 18
9 단 : 9 * 3 = 27
9 단 : 9 * 4 = 36
9 단 : 9 * 5 = 45
9 단 : 9 * 6 = 54
9 단 : 9 * 7 = 63
9 단 : 9 * 8 = 72
9 단 : 9 * 9 = 81
8 단 : 8 * 1 = 8
8 단 : 8 * 2 = 16
8 단 : 8 * 3 = 24
8 단 : 8 * 4 = 32
8 단 : 8 * 5 = 40
8 단 : 8 * 6 = 48
8 단 : 8 * 7 = 56
8 단 : 8 * 8 = 64
8 단 : 8 * 9 = 72
6 단 : 6 * 1 = 6
6 단 : 6 * 2 = 12
6 단 : 6 * 3 = 18
6 단 : 6 * 4 = 24
6 단 : 6 * 5 = 30
6 단 : 6 * 6 = 36
6 단 : 6 * 7 = 42
6 단 : 6 * 8 = 48
6 단 : 6 * 9 = 54
2 단 : 2 * 1 = 2
2 단 : 2 * 2 = 4
2 단 : 2 * 3 = 6
2 단 : 2 * 4 = 8
2 단 : 2 * 5 = 10
2 단 : 2 * 6 = 12
2 단 : 2 * 7 = 14
2 단 : 2 * 8 = 16
2 단 : 2 * 9 = 18
3 단 : 3 * 1 = 3
3 단 : 3 * 2 = 6
3 단 : 3 * 3 = 9
3 단 : 3 * 4 = 12
3 단 : 3 * 5 = 15
3 단 : 3 * 6 = 18
3 단 : 3 * 7 = 21
3 단 : 3 * 8 = 24
3 단 : 3 * 9 = 27
7 단 : 7 * 1 = 7
7 단 : 7 * 2 = 14
7 단 : 7 * 3 = 21
7 단 : 7 * 4 = 28
7 단 : 7 * 5 = 35
7 단 : 7 * 6 = 42
7 단 : 7 * 7 = 49
7 단 : 7 * 8 = 56
7 단 : 7 * 9 = 63
5 단 : 5 * 1 = 5
5 단 : 5 * 2 = 10
5 단 : 5 * 3 = 15
5 단 : 5 * 4 = 20
5 단 : 5 * 5 = 25
5 단 : 5 * 6 = 30
5 단 : 5 * 7 = 35
5 단 : 5 * 8 = 40
5 단 : 5 * 9 = 45
4 단 : 4 * 1 = 4
4 단 : 4 * 2 = 8
4 단 : 4 * 3 = 12
4 단 : 4 * 4 = 16
4 단 : 4 * 5 = 20
4 단 : 4 * 6 = 24
4 단 : 4 * 7 = 28
4 단 : 4 * 8 = 32
4 단 : 4 * 9 = 36

 

 

ex----------------------

 

public class Thread_E04 {

 public static void main(String[] args) {
  Thread t2 = new Thread(new GooGoo_Sleep(2));
  Thread t3 = new Thread(new GooGoo_Sleep(3));
  Thread t4 = new Thread(new GooGoo_Sleep(4));
  Thread t5 = new Thread(new GooGoo_Sleep(5));
  Thread t6 = new Thread(new GooGoo_Sleep(6));
  Thread t7 = new Thread(new GooGoo_Sleep(7));
  Thread t8 = new Thread(new GooGoo_Sleep(8));
  Thread t9 = new Thread(new GooGoo_Sleep(9));
  
  t2.start();
  t3.start();
  t4.start();
  t5.start();
  t6.start();
  t7.start();
  t8.start();
  t9.start();

 

  System.out.println("main 종료");
 }
}

class GooGoo_Sleep implements Runnable{
 int dan;
 
 public GooGoo_Sleep(int dan){
  this.dan = dan;
 }
 @Override
 public void run() {
  Long sleepTime = (long) (Math.random() * 500);
  System.out.println(dan + "단은 " + sleepTime + "만큼 sleep..");
  try {
   Thread.sleep(sleepTime);
  } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
  for(int i = 1; i <= 9; i++){
   System.out.println(dan + " 단 : "+ dan + " * " + i + " = " + dan * i);
  }
 }
}