was ist der Vorteil der Verwendung von FutureTask mehr Aufrufbar?

Mit Zukunft können wir herausfinden, den status der Callable Aufgabe und erhalten Sie das zurückgegebene Objekt. Es liefert get () - Methode, die warten kann, bis das Callable zu beenden und dann das Ergebnis zurückgeben.

Zukunft bietet cancel () - Methode zum Abbrechen der damit verbundenen Callable task). Es ist eine überladene version von get () - Methode, wo wir angeben können, die Zeit auf das Ergebnis warten, es ist sinnvoll, zu vermeiden, aktuellen thread blockiert für längere Zeit. Es gibt isDone() und isCancelled() Methoden, um herauszufinden, den aktuellen status der zugeordneten Callable task.

Hier ist ein einfaches Beispiel des Callable task liefert den Namen des thread ausführen der Aufgabe nach einer Sekunde. Wir sind mit Executor-framework zum ausführen 100 Aufgaben parallel und Zukunft verwenden, um das Ergebnis der eingereichten Aufgaben.

    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;

    public class MyCallable implements Callable<String> {

        @Override
        public String call() throws Exception {
            Thread.sleep(1000);
            //return the thread name executing this callable task
            return Thread.currentThread().getName();
        }

        public static void main(String args[]){
            //Get ExecutorService from Executors utility class, thread pool size is 10
            ExecutorService executor = Executors.newFixedThreadPool(10);
            //create a list to hold the Future object associated with Callable
            List<Future<String>> list = new ArrayList<Future<String>>();
            //Create MyCallable instance
            Callable<String> callable = new MyCallable();
            for(int i=0; i< 100; i++){
                //submit Callable tasks to be executed by thread pool
                Future<String> future = executor.submit(callable);
                //add Future to the list, we can get return value using Future
                list.add(future);
            }
            for(Future<String> fut : list){
                try {
                    //print the return value of Future, notice the output delay in console
                    //because Future.get() waits for task to get completed
                    System.out.println(new Date()+ "::"+fut.get());
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }
            //shut down the executor service now
            executor.shutdown();
        }
    }

Wo, wie FutureTask ist die Basis konkrete Umsetzung der Zukünftigen Benutzeroberfläche und bietet die asynchrone Verarbeitung. Es enthält die Methoden zum starten und Abbrechen einer Aufgabe und auch die Methoden, die zurückkehren kann, den Zustand der FutureTask als ob es abgeschlossen oder abgebrochen. Wir brauchen ein callable-Objekt zu erstellen, die eine zukünftige Aufgabe und dann können wir Java Thread-Pools Executor, diese zu verarbeiten asynchron.

Schauen wir uns das Beispiel von FutureTask mit einem einfachen Programm.

Da FutureTask erfordert ein callable-Objekt, erstellen wir ein einfaches Callable Umsetzung.

    public class MyCallable implements Callable<String> {

    private long waitTime;

    public MyCallable(int timeInMillis){
        this.waitTime=timeInMillis;
    }
    @Override
    public String call() throws Exception {
        Thread.sleep(waitTime);
        //return the thread name executing this callable task
        return Thread.currentThread().getName();
    }

}

    import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.FutureTask;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class FutureTaskExample {

    public static void main(String[] args) {
        MyCallable callable1 = new MyCallable(1000);
        MyCallable callable2 = new MyCallable(2000);

        FutureTask<String> futureTask1 = new FutureTask<String>(callable1);
        FutureTask<String> futureTask2 = new FutureTask<String>(callable2);

        ExecutorService executor = Executors.newFixedThreadPool(2);
        executor.execute(futureTask1);
        executor.execute(futureTask2);

        while (true) {
            try {
                if(futureTask1.isDone() && futureTask2.isDone()){
                    System.out.println("Done");
                    //shut down executor service
                    executor.shutdown();
                    return;
                }

                if(!futureTask1.isDone()){
                //wait indefinitely for future task to complete
                System.out.println("FutureTask1 output="+futureTask1.get());
                }

                System.out.println("Waiting for FutureTask2 to complete");
                String s = futureTask2.get(200L, TimeUnit.MILLISECONDS);
                if(s !=null){
                    System.out.println("FutureTask2 output="+s);
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }catch(TimeoutException e){
                //do nothing
            }
        }

    }

}