java-concurrency-Callable, Future 및 FutureTask

스레드를 생성하는 방법에는 두 가지가 있는데, 하나는 Thread를 직접 상속하는 것과 Runnable 인터페이스를 구현하는 것입니다.

차이점: 인터페이스는 다중 상속을 구현할 수 있습니다

결함 is: 작업을 실행한 후 나중에 실행 결과를 얻을 수 없습니다

Callable and Runnable

java.lang.Runnable

[code]public interface Runnable {
    public abstract void run();
}

run() 메서드의 반환 값 이후 void 유형이므로 작업을 실행한 후에는 얻을 수 없습니다. 결과가 반환되지 않습니다.

java.util.concurren

[code]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 유형입니다. 일반적으로 ExecutorService와 함께 사용되며 여러 submit 메소드의 오버로드된 버전은 ExecutorService 인터페이스

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

Future

Future에서 선언됩니다. Future는 특정 Runnable 또는 Callable 작업의 실행 결과를 취소하고 완료 여부를 쿼리한 후 해당 작업을 가져오는 것입니다. 결과 . 필요한 경우 get 메소드를 통해 실행 결과를 얻을 수 있습니다. 이 메소드는 작업이 결과를 반환할 때까지 차단됩니다.

[code]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;
}

취소 메소드는 작업 취소에 성공하면 반환됩니다. true입니다. 작업 취소에 실패하면 false를 반환합니다. mayInterruptIfRunning 매개변수는 실행 중이지만 완료되지 않은 작업을 취소할 수 있는지 여부를 나타냅니다. true로 설정하면 실행 중인 작업을 취소할 수 있다는 의미입니다. 작업이 완료되면 mayInterruptIfRunning이 true인지 false인지에 관계없이 이 메서드는 확실히 false를 반환합니다. 즉, 완료된 작업이 취소되면 작업이 실행 중이고 mayInterruptIfRunning이 true로 설정된 경우 false를 반환합니다. mayInterruptIfRunning이 false로 설정된 경우 true를 반환하고 작업이 실행되지 않은 경우 mayInterruptIfRunning이 true인지 false인지에 관계없이 false를 반환합니다.

isCancelled 메소드는 작업이 정상적으로 완료되기 전에 작업이 성공적으로 취소되었는지 여부를 나타냅니다.

isDone 메소드는 작업이 완료되었는지 여부를 나타냅니다.

get() 메소드는 실행 결과를 얻는 데 사용됩니다. 작업이 완료될 때까지 기다린 후 반환합니다.

get(long timeout, TimeUnit 단위)을 사용하여 지정된 시간 내에 결과를 얻지 못하면 null이 직접 반환됩니다.

즉, Future는 세 가지 기능을 제공합니다.

1) 작업이 완료되었는지 확인합니다.

2) 작업을 중단할 수 있습니다. > 3) 작업 실행 결과를 얻을 수 있습니다.

Future는 단순한 인터페이스이기 때문에 객체 생성에 직접 사용할 수 없으므로 다음과 같은 FutureTask가 있습니다.

FutureTask

[code]public class FutureTask<V> implements RunnableFuture<V>

[code]public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

[code]public FutureTask(Callable<V> callable) {
}
public FutureTask(Runnable runnable, V result) {
}

사실 FutureTask는 Future 인터페이스의 유일한 구현 클래스입니다.

예

[code]public class Test {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        Task task = new Task();
        Future<Integer> result = executor.submit(task);
        executor.shutdown();

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e1) {
            e1.printStackTrace();
        }

        System.out.println("主线程在执行任务");

        try {
            System.out.println("task运行结果"+result.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;
    }
}

[code]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;
    }
}

취소성을 위해 Future를 사용했지만 사용 가능한 결과를 제공하지 않는 경우 Future를 선언할 수 있습니다