Java Callable 및 FutureTask 에 반환 값, 상태 제어 가능한 다중 스레드

1. Callable 나머지 FutureTask 소개
먼저 자바에 대해 얘기해 주세요.lang.Runnable 은 인터페이스입니다. 이 인터페이스에는 run () 방법만 설명되어 있습니다.

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

run () 방법은void 형식으로 되돌아오기 때문에 작업이 끝난 후에 결과를 되돌릴 수 없습니다.
Callable은 java에 있습니다.util.concurrent 패키지 아래, 그것도 하나의 인터페이스입니다. 그 안에서도 하나의 방법만 설명합니다. 단지 이 방법을call()라고 합니다.

public  interface  Callable<V> {
     /**
      * Computes a result, or throws an exception if unable to do so.
      *
      * @return computed result
      * @throws Exception if unable to compute a result
      */
     V call()  throws  Exception;
}

이것은 일반 인터페이스입니다.call () 함수가 되돌아오는 형식은 전달된 V 형식입니다.
그럼 Callable은 어떻게 사용하나요?일반적으로 Executor Service와 함께 사용되며 Executor Service 인터페이스에 다음과 같은 몇 가지 Submit 메서드 리셋 버전이 설명되어 있습니다.

<T> Future<T> submit(Callable<T> task);
<T> Future<T> submit(Runnable task, T result);
Future<?> submit(Runnable task);

첫 번째submit 방법의 매개 변수 형식은Callable입니다.
당분간 캘러블은 일반적으로 Executor 서비스와 협조하여 사용하는 것으로 알고 구체적인 사용 방법은 뒤에 설명하겠습니다.
일반적인 상황에서 우리는 첫 번째submit 방법과 세 번째submit 방법을 사용하고 두 번째submit 방법은 매우 적게 사용한다.
Future는 구체적인 Runnable 또는 Callable 작업의 실행 결과를 취소하고 완성 여부를 조회하며 결과를 얻는 것입니다.필요할 때 get 방법으로 실행 결과를 얻을 수 있습니다. 이 방법은 작업이 결과를 되돌릴 때까지 막힙니다.
Future 클래스는 java에 있습니다.util.concurrent 패키지 아래에는 인터페이스가 있습니다.

public  interface  Future<V> {
     boolean  cancel( boolean  mayInterruptIfRunning);
     boolean  isCancelled();
     boolean  isDone();
     V get()  throws  InterruptedException, ExecutionException;
     V get( long  timeout, TimeUnit unit)
         throws  InterruptedException, ExecutionException, TimeoutException;
}

Future 인터페이스에서 설명하는 5가지 방법은 다음과 같습니다.

cancel 방법은 작업을 취소하는 데 사용되며, 작업을 취소하는 데 성공하면true로 돌아가고, 작업을 취소하는 데 실패하면false로 돌아갑니다.매개 변수mayInterruptIfRunning은 실행 중이지만 완료되지 않은 작업을 취소할 수 있는지 여부를 나타내고true를 설정하면 실행 중인 작업을 취소할 수 있음을 나타냅니다.만약 작업이 이미 완성되었다면mayInterruptIfRunning이true든false든지 간에 이 방법은false로 되돌아갈 것이다. 즉, 이미 완성된 작업을 취소하면false로 되돌아갈 것이다.작업이 실행 중이면 mayInterruptIfRunning이true로 설정되면true로 돌아가고 mayInterruptIfRunning이false로 설정되면false로 돌아갑니다.작업이 실행되지 않은 경우 mayInterruptIfRunning이true이든false이든true로 돌아갑니다.

isCancelled 메서드는 작업이 취소되었는지 여부를 나타내며, 작업이 정상적으로 완료되기 전에 취소되었을 경우true로 돌아갑니다.

isDone 방법은 임무가 이미 완성되었는지 여부를 표시하고 임무가 완성되면true로 되돌아간다.

get() 방법은 실행 결과를 가져오는 데 사용되며, 이 방법은 막혀서 작업이 끝난 후에 돌아옵니다.

get(long timeout, Time Unit unit)은 실행 결과를 가져오는 데 사용되며, 지정된 시간 안에 결과를 얻지 못하면 바로null로 돌아갑니다.

즉, Future는 세 가지 기능을 제공합니다.
1) 임무 수행 여부를 판단한다.
2) 작업을 중단할 수 있다.
3) 작업 수행 결과를 얻을 수 있습니다.
Future는 하나의 인터페이스이기 때문에 대상을 만드는 데 직접 사용할 수 없기 때문에 아래의 FutureTask가 있습니다.
2. Callable 이후 FutureTask 사용
2.1 간단한 사용

import java.util.concurrent.Callable;
import java.lang.Integer;

public class CallableTask implements Callable<Integer> {

	    @Override
	    public Integer call() throws Exception {
	    	int hours=5;
	    	int amount = 0;
	        while(hours>0){
	            System.out.println("I'm working,rest is "+hours);
	            amount++;
	            hours--;
	            Thread.sleep(1000);
	        }
	        return amount;
	    }
}

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;


public class Boss {
        
    public static void main(String args[]) throws ExecutionException{
        CallableTask worker = new CallableTask();
        FutureTask<Integer> jiangong = new FutureTask<Integer>(worker);
        new Thread(jiangong).start();
        
        while(!jiangong.isDone()){
            try {
                System.out.println("       ..."+jiangong.get());
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        int amount;
        try {
            amount = jiangong.get();
            System.out.println("     ,   "+amount);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        
    }
}

2.2 병렬 프로그래밍

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;

public class Test {
    public static void main(String[] args) {
        //     
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        executor.submit(futureTask);
        executor.shutdown();
         
        //     ，                  ，         ExecutorService，      Thread
        /*Task task = new Task();
        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);
        Thread thread = new Thread(futureTask);
        thread.start();*/
         
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }
        
        System.out.println("        ");
         
        try {
            System.out.println("task    "+futureTask.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
         
        System.out.println("        ");
    }
}
class Task implements Callable<Integer>{
    @Override
    public Integer call() throws Exception {
        System.out.println("        ");
        Thread.sleep(3000);
        int sum = 0;
        for(int i=0;i<100;i++)
            sum += i;
        return sum;
    }
}