자바 병렬 프로 그래 밍 테마(2)-자바 스 레 드 를 만 들 고 실행 하 는 방법

스 레 드 를 실현 하 는 두 가지 방식
지난 절우 리 는 스 레 드 에 관 한 기본 지식 을 알 게 되 었 고 다음 에 우 리 는 다 중 스 레 드 의 실현 부분 에 본 격 적 으로 들 어 갔다.스 레 드 를 실현 하 는 데 자주 사용 되 는 두 가지 방식 이 있 는데 하 나 는 Thread 류 를 계승 하 는 것 이 고 하 나 는 Runnable 인 터 페 이 스 를 실현 하 는 것 이다.물론 세 번 째 방법 도 있 습 니 다.그것 은 바로 스 레 드 탱크 를 통 해 스 레 드 를 만 드 는 것 입 니 다.그 다음 에 우 리 는 배 워 서 한 걸음 한 걸음 발자국 에 기 초 를 다 지 는 것 입 니 다.
Runnable 인터페이스:

public interface Runnable {
 public abstract void run();
}

Thread 클래스:

public class Thread implements Runnable {
 public synchronized void start() {  
  if (threadStatus != 0)
   throw new IllegalThreadStateException();  
  group.add(this);
  boolean started = false;
  try {
   start0();
   started = true;
  } finally {
   try {
    if (!started) {
     group.threadStartFailed(this);
    }
   } catch (Throwable ignore) {
    /* do nothing. If start0 threw a Throwable then
     it will be passed up the call stack */
   }
 }
 @Override
 public void run() {
  if (target != null) {
   target.run();
  }
 }
}

위 는 Thread 류 와 Runnable 류 의 소스 코드 입 니 다.Thread 류 도 Runnable 인 터 페 이 스 를 실현 한 것 을 볼 수 있 습 니 다.즉,Thread 는 Runnable 의 실현 입 니 다.그러면 그들 은 도대체 다 중 스 레 드 를 실현 하 는 데 어떤 차이 가 있 습 니까?
Thread 와 Runnable 해석:
(1)Runnable 인터페이스:
Runnable 인 터 페 이 스 는 자바 의 스 레 드 정의 클래스 입 니 다.모든 스 레 드 는 이 인 터 페 이 스 를 통 해 이 루어 집 니 다.이 인터페이스의 run()방법 은 실현 방법 입 니 다.즉,스 레 드 가 실현 하고 자 하 는 내용 을 이 방법 에 기록 하고 스 레 드 가 시 작 될 때 이 방법 을 사용 합 니 다.
대부분의 경우 run()방법 만 다시 쓰 고 다른 방법 을 다시 쓰 지 않 으 려 면 Runnable 인 터 페 이 스 를 사용 해 야 합 니 다.

public class ThreadDemo3 {   
 public static void main(String[] args) { 
  //new       ――s1 s2
  //               。                      
  Shop1 s1 = new Shop1("  ");
  s1.start();

  Shop1 s2 = new Shop1("  ");
  s2.start();   
  /*
  //          ，           
  //                
  Shop2 s3 = new Shop2("  ");
  s3.run();    
  Shop2 s4 = new Shop2("  ");
  s4.run();   
  //            
  //            
  Thread t1 = new Thread(new Shop2("  "));
  t1.start();

  Thread t2 = new Thread(new Shop2("  "));
  t2.start();
  */   
  //         ，           ――s6 
  Shop2 s5 = new Shop2("w");  
  Shop1 s6 = new Shop1("T");
  Thread t3 = new Thread(s6);
  t3.start();

  Thread t4 =new Thread(s6);
  t4.start();      
 }
}

/**
 *       （       ，            ）
 *    ：    10 
 *
 */
class Shop1 extends Thread{
 //private int count = 10;
 //                 （          count）
 private static int count = 10;
 public Shop1(String name) {
  super(name);
 }
 public void run(){
  //        
  while(count>0){
   count--;
   System.out.println(this.getName() +"       " + ",    " + count);
  }
 }
}

/**
 *            
 *
 */
class Shop2 implements Runnable{
 //    ，         
 private int count = 10;
 //        
 private String name="";

 public Shop2(String name) {
  this.name = name;
 }

 /**
  *        
  */
 public void run(){
  //        
  while(count>0){
   count--;
   System.out.println(Thread.currentThread().getId() + "、" + this.name +"       " + ",    " + count);
  }
 }
}

(2)Thread 클래스:
Thread 클래스 는 Runnable 인터페이스의 실현 입 니 다.jdk 는 우리 가 스 레 드 를 어떻게 실현 할 지 생각 하지 않 아 도 되 는 방식 을 제공 합 니 다.마찬가지 로 Thread 클래스 를 계승 할 때 도 run()방법 을 다시 써 서 스 레 드 에서 이 루 고 싶 은 내용 을 실현 해 야 합 니 다.

public class Test{
  public static void main(String[] args) {
    //    ――     
    /*
    SimpleClass sc1 = new SimpleClass();
    sc1.say("Mike");

    SimpleClass sc2 = new SimpleClass();
    sc2.say("Han Meimei");
    */
    //      
    ThreadClass tc1 = new ThreadClass("Mike");
    //    
    tc1.start();
    //      
    ThreadClass tc2 = new ThreadClass("Han Meimei");
    tc2.start();

   } 
  }
 }

 class SimpleClass{
  public void say(String name){
   while(true){
    System.out.println("Hi,Im " + name);
   }
  }
 }
 class ThreadClass extends Thread{
  public ThreadClass(String name) {
   super(name);
  }

  /**
   *    （Thread） run()      
   *  run()             
   */
  public void run(){
   while(true){
    System.out.println("Hi,Im " + this.getName() + "|" + this.getId() + "|" + this.getStackTrace());
   }
  }
 }

Thread 클래스 에서 자주 사용 하 는 방법:
run():이 스 레 드 에서 독립 된 Runnable 실행 대상 구 조 를 사용 하면 이 Runnable 대상 의 run 방법 을 호출 합 니 다.그렇지 않 으 면 이 방법 은 어떠한 조작 도 하지 않 고 되 돌아 갑 니 다.
sleep(longmills):지정 한 밀리초 내 에 현재 실행 중인 스 레 드 를 휴면 시 킵 니 다(실행 정지).이 작업 은 시스템 타이머 와 스케줄 러 의 정밀도 와 정확성 에 영향 을 받 습 니 다 String
yield():현재 실행 중인 스 레 드 대상 을 일시 정지 하고 다른 스 레 드 start()를 실행 합 니 다.이 스 레 드 를 실행 시 키 고 자바 가상 머 신 은 이 스 레 드 의 run 방법 을 다시 호출 합 니 다.
join():이 스 레 드 가 끝 날 때 까지 기 다 립 니 다.
대비:
위 에서 Thread 와 Runnable 의 실현 을 보 여 주 었 습 니 다.Runnable 방식 으로 스 레 드 를 실현 하 는 과정 에서 볼 수 있 습 니 다.

 Shop1 s6 = new Shop1("T");
 Thread t3 = new Thread(s6);
 t3.start();

즉,Runnable 대상(Runnable 인 터 페 이 스 를 실현 한 대상)을 Thread 에 넣 어 Thread 를 실현 하 는 것 입 니까?그러면 우 리 는 new 여러 Thread 로 같은 Runnbale 대상 을 실현 할 수 있 습 니 다.즉,자원 의 공 유 를 실현 할 수 있 습 니 다.예 를 들 어 매 표 시스템 에서 여러 명의 사용자 가 같은 표 에 대한 사재 기 를 실현 할 수 있 습 니 다.다른 한편,자 바 는 단일 계승 다 중 실현 이다.만약 에 우리 가 Thread 를 사용한다 면 이 종 류 는 Thread 만 계승 할 수 있 고 프로그램의 확장 에 불리 하 며 Runnbale 인 터 페 이 스 를 실현 하 는 것 은 이런 걱정 이 없다.프로그램의 건장 성 을 고려 하여 우 리 는 가능 한 한 Runnable 을 사용 하여 우리 의 스 레 드 를 실현 해 야 한다.
run 과 start
다 중 스 레 드 를 처음 배 울 때 우 리 는 run()방법 과 start()방법의 차 이 를 잘 구분 하지 못 합 니 다.사실은 위 에 있 는 Thread 류 의 소스 코드 를 다시 보면 그들의 용법 이 쉽게 구분 되 는 것 을 발견 하기 어렵 지 않 습 니 다.

run()방법 은 스 레 드 의 실현 방법 입 니 다.즉,스 레 드 가 무엇 을 해 야 하 는 지,이러한 실현 내용 은 run()에 쓰 여 있 습 니 다.스 레 드 가 시 작 될 때 run()방법 을 호출 하여 run()내부 코드 를 실현 합 니 다.

start()방법 은 스 레 드 의 시작 방법 입 니 다.즉,new Thread()가 이렇게 끝나 지 않 는 다 면.new Thread().start()가 있어 야 이 스 레 드 를 시작 할 수 있 습 니 다.시작 한 후에 스 레 드 내부 에서 run()방법 으로 이 스 레 드 의 업무 논리 코드 를 주동 적 으로 호출 합 니 다.

이상 은 자바 병렬 프로 그래 밍 테마(2)-자바 스 레 드 를 어떻게 만 들 고 실행 하 는 지 에 대한 상세 한 내용 입 니 다.자바 스 레 드 를 만 들 고 실행 하 는 방법 에 대한 자 료 는 우리 의 다른 관련 글 에 관심 을 가 져 주 십시오!