Callable

 

 

package test.com.hisi.d;

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;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DTest {

    public static void main(String[] args) {
        int timeout = 2;
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Boolean result = false;
        Future<Boolean> future = executor.submit(new TaskThread("發送請求"));//將任務提交給線程池
        try {
            System.out.println("begin:");
            result = future.get(timeout, TimeUnit.SECONDS);   //1
            //result = future.get(timeout, TimeUnit.MILLISECONDS); //2
            System.out.println("發送請求任務的返回結果： " + result);  
        } catch (InterruptedException e) {
            System.out.println("線程中斷出錯。");
            future.cancel(true);// 中斷執行此任務的線程
        } catch (ExecutionException e) {
            System.out.println("線程服務出錯。");
            future.cancel(true);
        } catch (TimeoutException e) {// 超時異常
            System.out.println("超時。");
            future.cancel(true);
        } finally {
            System.out.println("線程服務關閉。");
            executor.shutdown();
        }
    }

    static class TaskThread implements Callable<Boolean> {
        private String task;

        public TaskThread(String temp) {
            this.task = temp;
        }

        public Boolean call() {
            //for用於模擬超時
            for (int i = 0; i < 999999999; i++) {
                if (i == 999999998) {
                    System.out.println(task + " 成功！");
                }
                if (Thread.interrupted()) {
                    System.out.println("---interrupted----");
                    return false;
                }
            }
            System.out.println("繼續執行..........");
            return true;
        }
    }
}

begin:
發送請求 成功！
繼續執行..........
發送請求任務的返回結果： true
線程服務關閉。

--------------------------------------

若使用result = future.get(timeout, TimeUnit.MILLISECONDS);則結果為

begin:
超時。
---interrupted----
線程服務關閉。

package test.com.hisi.d;

import java.util.concurrent.Callable;

class MyCallable implements Callable<Object> {
    private int flag;

    public MyCallable(int flag) {
        this.flag = flag;
    }

    public String call() throws Exception {
        if (this.flag == 0) {
            return "flag = 0";
        }

        if (this.flag == 1) {
            try {
                while (true) {
                    System.out.println("looping.");
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                System.out.println("Interrupted");
            }

            return "false";
        } else {
            throw new Exception("Bad flag value!");
        }
    }
}

 

package test.com.hisi.d;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FutureGetBlock {

    public static void main(String[] args) {
        // 定義3個Callable類型的任務
        MyCallable task1 = new MyCallable(0);
        MyCallable task2 = new MyCallable(1);
        MyCallable task3 = new MyCallable(2);
        // 創建一個執行任務的服務
        ExecutorService es = Executors.newFixedThreadPool(3);

        try {
            // 提交並執行任務，任務啟動時返回了一個Future對象，
            // 如果想得到任務執行的結果或者是異常可對這個Future對象進行操作
            Future<?> future1 = es.submit(task1);
            // 獲得第一個任務的結果，如果調用get方法，當前線程會等待任務執行完畢后才往下執行
            System.out.println("task1: " + future1.get());
            Future<?> future2 = es.submit(task2);
            // 等待5秒后，再停止第二個任務。因為第二個任務進行的是無限循環
            Thread.sleep(5000);
            System.out.println("task2 cancel: " + future2.cancel(true));
            // 獲取第三個任務的輸出，因為執行第三個任務會引起異常
            // 所以下面的語句將引起異常的拋出
            Future<?> future3 = es.submit(task3);
            System.out.println("task3: " + future3.get());
        } catch (Exception e) {
            System.out.println(e.toString());
        }

        // 停止任務執行服務
        es.shutdownNow();
    }
}

task1: flag = 0
looping.
looping.
looping.
Interrupted
task2 cancel: true
java.util.concurrent.ExecutionException: java.lang.Exception: Bad flag value!