线程回调-实现Callable接口

线程回调-实现Callable<T>接口

线程回调顾名思义就是获取一个线程中返回的结果，通过实现接口Callable<T>来实现。

例子:

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.Future;
class Mythread implements Callable<String>{
      int i = 0;     
      public Mythread(int i) {
            this.i = i;
            }
      @Override
      public String call() throws Exception {
            // TODO Auto-generated method stub
            System.out.println("线程启动---" + Thread.currentThread().getName()
                        + new Date());
            try {
                  Thread.sleep(i);
                  System.out.println("休眠了"+i+"毫秒 线程结束---" + Thread.currentThread().getName()
                              + new Date());
            } catch (Exception e) {
                  // TODO: handle exception
            }
             return "sucess"+i;
      };    
}
public class 线程池执行完毕后返回结果 {
      public static ExecutorService cachedThreadPool = Executors
                  .newFixedThreadPool(20);
      public static void main(String[] args) {
            ArrayList<Mythread> list = new ArrayList<Mythread>();
            for (int i = 0; i < 7; i++) {
                  list.add(new Mythread(i*1000));
            }
            try {
                  List<Future<String>> invokeAll = cachedThreadPool.invokeAll(list);
                  System.out.println("--------------------------------------");
                  for (Future<String> fu : invokeAll) {
                  System.out.println(fu.get());
                  }
            } catch (InterruptedException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
            } catch (ExecutionException e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
            }      
      }
}

 控制台打印输出:

通过控制台打印的结果我们能发现:

所谓的线程回调就是获取线程中返回的结果。