자바 스 레 드 대비(Thread,Runnable,Callable)인 스 턴 스 상세 설명

Java 스 레 드 대비 스 레 드,실행 가능,호출 가능
자바 는 Thread 류 대표 스 레 드 를 사용 합 니 다.모든 현장 대상 은 Thread 류 나 하위 클래스 의 인 스 턴 스 여야 합 니 다.모든 스 레 드 의 역할 은 일정한 임 무 를 완성 하 는 것 이 고 사실은 프로그램 흐름 을 수행 하 는 것 이다.자바 는 이 프로그램의 흐름 을 대표 하기 위해 스 레 드 실행 체 를 사용 합 니 다.
1.Thread 클래스 를 계승 하여 스 레 드 만 들 기
다 중 스 레 드 를 시작 하 는 절 차 는 다음 과 같 습 니 다.
(1)Thread 클래스 의 하위 클래스 를 정의 하고 이 클래스 의 run()방법 을 다시 작성 합 니 다.이 run()방법의 방법 체 는 클래스 스 레 드 가 완성 해 야 할 작업 을 대표 합 니 다.따라서 run()방법 을 스 레 드 실행 체 라 고 합 니 다.
(2)스 레 드 하위 클래스 를 만 드 는 인 스 턴 스,즉 스 레 드 대상 을 만 드 는 것 입 니 다.
(3)스 레 드 의 star()방법 을 호출 하여 이 스 레 드 를 시작 합 니 다.
관련 코드 는 다음 과 같 습 니 다.

/**
   *    thread     ，     
   */
  public class FirstThread extends Thread{
    private int i;
    private int ticket = 10;

    @Override
    public void run() {
      for (;i<20;i++) {
        //   thread  ，    this          ,getName（）          
//        Log.d(TAG,getName()+" "+i);

        if(this.ticket>0){
          Log.e(TAG, getName() + ",   ：ticket=" + ticket--);
        }
      }

    }
  }

  private void starTicketThread(){
    Log.d(TAG,"starTicketThread, "+Thread.currentThread().getName());

    FirstThread thread1 = new FirstThread();
    FirstThread thread2 = new FirstThread();
    FirstThread thread3 = new FirstThread();

    thread1.start();
    thread2.start();
    thread3.start();

    //  3       ，       10 ，   30  

  }

실행 결과:

3 개의 스 레 드 가 입력 한 표 변수 가 연속 되 지 않 는 것 을 볼 수 있 습 니 다.주의:ticket 은 부분 변수 가 아 닌 FirstThread 의 인 스 턴 스 속성 입 니 다.그러나 프로그램 이 스 레 드 대상 을 만 들 때마다 FirstThread 대상 을 만들어 야 하기 때문에 모든 스 레 드 는 이 인 스 턴 스 의 소속 성 을 공유 하지 않 습 니 다.
2.Runnable 인터페이스 생 성 스 레 드 실현
메모:public class Thread implements 실행 가능
(1)Runnable 인터페이스의 실현 클래스 를 정의 하고 이 인터페이스의 run()방법 을 다시 작성 합 니 다.이 run()방법의 방법 체 는 이 스 레 드 의 스 레 드 실행 체 입 니 다.
(2)Runnable 인 스 턴 스 클래스 의 인 스 턴 스 를 만 듭 니 다.이 인 스 턴 스 는 Thread 의 target 으로 Thread 대상 을 만 듭 니 다.이 Thread 대상 이 야 말로 진정한 대상 입 니 다.
관련 코드 는 다음 과 같 습 니 다.

/**
   *    runnable   ，     
   */
  public class SecondThread implements Runnable{

    private int i;
    private int ticket = 100;

    @Override
    public void run() {
      for (;i<20;i++) {
        //        runnable   
        //       ，    Thread.currentThread()         
        Log.d(TAG,Thread.currentThread().getName()+" "+i);

        if(this.ticket>0){
          Log.e(TAG, Thread.currentThread().getName() + ",   ：ticket=" + ticket--);
        }
      }
    }
  }


  private void starTicketThread2(){
    Log.d(TAG,"starTicketThread2, "+Thread.currentThread().getName());

    SecondThread secondThread = new SecondThread();

    //  new Thread(target,name)      
    new Thread(secondThread,"   1").start();
    new Thread(secondThread,"   2").start();
    new Thread(secondThread,"   3").start();

    //      3   ，       100  
  }

실행 결과:

3 개의 스 레 드 가 입력 한 표 변 수 는 연속 적 인 것 을 볼 수 있 습 니 다.Runnable 인터페이스 방식 으로 여러 스 레 드 를 만 들 면 스 레 드 류 의 인 스 턴 스 속성 을 공유 할 수 있 습 니 다.이 는 이러한 방식 에서 프로그램 이 만 든 Runnable 대상 은 스 레 드 의 target 일 뿐 여러 스 레 드 는 같은 target 을 공유 할 수 있 기 때문에 여러 스 레 드 는 같은 스 레 드 류(실제 이 스 레 드 의 target 류)의 인 스 턴 스 속성 을 공유 할 수 있 습 니 다.
3.Callable 과 Future 를 사용 하여 스 레 드 만 들 기
자바 5 부터 자바 는 Callable 인 터 페 이 스 를 제공 합 니 다.이 인 터 페 이 스 는 runnable 의 증강 판 입 니 다.Callable 은 하나의 call()방법 을 제공 하여 스 레 드 실행 체 로 사용 할 수 있 지만 call()방법의 기능 은 더욱 강 합 니 다.
(1)call()방법 은 반환 값 이 있 을 수 있 습 니 다.
(2)call()방법 은 이상 을 선언 할 수 있 습 니 다.
따라서 저 희 는 callable 대상 을 Thread 의 target 으로 제공 할 수 있 습 니 다.이 스 레 드 의 실행 체 는 이 callable 대상 의 call()방법 입 니 다.또한 자바 5 는 Callable 인터페이스 에서 call()방법의 반환 값 을 나타 내 는 Future 인 터 페 이 스 를 제공 하고 future Task 의 실현 클래스 를 제공 합 니 다.이 실현 클래스 는 future 인터페이스 와 runnable 인 터 페 이 스 를 실현 합 니 다.Thread 클래스 의 target 으로 사용 할 수 있 습 니 다.
시작 단 계 는 다음 과 같 습 니 다.
(1)callable 인터페이스의 실현 클래스 를 만 들 고 call()방법 을 실현 합 니 다.이 call()방법 은 스 레 드 의 실행 체 로 서 이 call()방법 은 반환 값 이 있 습 니 다.
(2)callable 구현 클래스 의 인 스 턴 스 를 만 들 고 FutureTask 클래스 를 사용 하여 Callable 대상 을 포장 합 니 다.이 FutureTask 대상 은 call()방법의 반환 값 을 패키지 합 니 다.
(3)FutureTask 대상 을 Thread 대상 의 target 으로 사용 하여 새 스 레 드 를 만 들 고 시작 합 니 다.
(4)Future Task 대상 의 get()방법 을 호출 하여 하위 스 레 드 실행 이 끝 난 후의 반환 값 을 가 져 옵 니 다.
관련 코드 는 다음 과 같 습 니 다.

/**
   *   callable       
   */
  public class ThirdThread implements Callable<Integer>{

    private int ticket = 20;

    @Override
    public Integer call(){

      for ( int i = 0;i<10;i++) {
        //       ，    Thread.currentThread()         
//        Log.d(TAG,Thread.currentThread().getName()+" "+i);

        if(this.ticket>0){
          Log.e(TAG, Thread.currentThread().getName() + ",   ：ticket=" + ticket--);
        }
      }


      return ticket;
    }
  }

  private void starCallableThread(){
    ThirdThread thirdThread = new ThirdThread();
    FutureTask<Integer> task = new FutureTask<Integer>(thirdThread);

    new Thread(task,"       ").start();

    try {
      Integer integer = task.get();
      Log.d(TAG,"starCallableThread,        ="+integer);

    } catch (InterruptedException e) {
      e.printStackTrace();
    } catch (ExecutionException e) {
      e.printStackTrace();
    }

  }

실행 결과:

메모:Callable 의 call()방법 은 이상 을 던 질 수 있 고 반환 값 을 가 질 수 있 습 니 다.
프로그램 은 마지막 으로 Future Task 대상 의 get()방법 을 호출 하여 Call()방법의 반환 값 을 되 돌려 주 며,주 스 레 드 가 차단 되 어 call()방법 이 끝나 고 돌아 올 때 까지 합 니 다.
4.세 가지 방식 의 비교
Thread 클래스 를 계승 하 는 방식 으로 다 중 스 레 드 를 만 듭 니 다.
약점:Thread 류 를 물 려 받 았 으 니 다른 부 류 를 물 려 받 을 수 없습니다.
장점:간단 한 작성
Runnable,Callable 인 터 페 이 스 를 계승 하 는 방식 으로 다 중 스 레 드 를 만 듭 니 다.
약점:프로 그래 밍 이 좀 복잡 합 니 다.현재 스 레 드 에 접근 하려 면 Thread.current Thread()를 사용 해 야 합 니 다.
우세:
(1)다른 종 류 를 계승 할 수 있다.
(2)여러 개의 스 레 드 는 하나의 target 대상 을 공유 할 수 있 기 때문에 같은 스 레 드 로 같은 자원 의 상황 을 처리 하고 cpu,코드 와 데 이 터 를 분리 하여 뚜렷 한 모델 을 형성 하여 대상 을 대상 으로 하 는 사상 을 잘 나타 낸다.
읽 어 주 셔 서 감사합니다. 여러분 에 게 도움 이 되 기 를 바 랍 니 다.본 사이트 에 대한 여러분 의 지지 에 감 사 드 립 니 다!