Java多线程之Callable接口的实现

 
自从Java平台的最开始，Runnable接口就已存在了。它允许你定义一个可由线程完成的任务。如大多数人所已知的那样，它只提供了一个run方法，
该方法既不接受任何参数，也不返回任何值。如果你需要从一个未完成的任务中返回一个值，你就必须在该接口之外使用一个方法去等待该任务完成时通报的某种消
息。

J2SE 5.0引入的Callable接口。不同于Runnable接口拥有run方法，Callable接口提供的是call方法，该方法可以返回一个Object对象，或可返回任何一个在泛型化格式中定义了的特定类型的对象。

 public interface Callable<V> {
       V call() throws Exception;
}

因为你不可能把Callable对象传到Thread对象去执行，你可换用ExecutorService对象去执行Callable对象。该服务接受Callable对象，并经由submit方法去执行它。
    <T> Future<T> submit(Callable<T> task)
如该方法的定义所示，提交一个Callable对象给ExecutorService会返回一个Future对象。然后，Future的get方法将会阻塞，直到任务完成。
   
为了证明这一点，下面的例子为命令行中的每个词都创建一个单独的Callable实例，然后把这些词的长度加起来。各个Callable对象将只是计算它自己的词的长度之和。Futures对象的Set集合将被保存以便从中获得计算用的值。如果需要保持返回值的顺序，则可换用一个List对象。

 import java.util.*;
import java.util.concurrent.*;

public class CallableExample {

    public static class WordLengthCallable
            implements Callable {
        private String word;
        public WordLengthCallable(String word) {
            this.word = word;
        }
        public Integer call() {
            return Integer.valueOf(word.length());
        }
    }

    public static void main(String args[]) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        Set<Future<Integer>> set = new HashSet<Future&lg;Integer>>();
        for (String word: args) {
            Callable<Integer> callable = new WordLengthCallable(word);
            Future<Integer> future = pool.submit(callable);
            set.add(future);
        }
        int sum = 0;
        for (Future<Integer> future : set) {
            sum += future.get();
        }
        system.out.printf("The sum of lengths is %s%n", sum);
        system.exit(sum);
    }
}

 

 

   

import java.util.concurrent.Callable;     

import java.util.concurrent.ExecutorService;     

import java.util.concurrent.Executors;     

import java.util.concurrent.Future;     

    

/** *//**   

 * Callable 和 Future接口   

 * Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。   

 * Callable和Runnable有几点不同：   

 * （1）Callable规定的方法是call()，而Runnable规定的方法是run().   

 * （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。   

 * （3）call()方法可抛出异常，而run()方法是不能抛出异常的。   

 * （4）运行Callable任务可拿到一个Future对象，   

 * Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。   

 * 通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。   

 */    

public class CallableAndFuture {     

    

    /** *//**   

     * 自定义一个任务类，实现Callable接口   

     */    

    public static class MyCallableClass implements Callable{     

        // 标志位     

        private int flag = 0;     

        public MyCallableClass(int flag){     

            this.flag = flag;     

        }     

        public String call() throws Exception{     

            if (this.flag == 0){     

                // 如果flag的值为0，则立即返回     

                return "flag = 0";     

            }      

            if (this.flag == 1){     

                // 如果flag的值为1，做一个无限循环     

                try {     

                    while (true) {     

                        System.out.println("looping.");     

                        Thread.sleep(2000);     

                    }     

                } catch (InterruptedException e) {     

                    System.out.println("Interrupted");     

                }     

                return "false";     

            } else {     

                // falg不为0或者1，则抛出异常     

                throw new Exception("Bad flag value!");     

            }     

        }     

    }     

         

    public static void main(String[] args) {     

        // 定义3个Callable类型的任务     

        MyCallableClass task1 = new MyCallableClass(0);     

        MyCallableClass task2 = new MyCallableClass(1);     

        MyCallableClass task3 = new MyCallableClass(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();     

    }     

}    

 

 

[转】JAVA 笔记 Callable 与 FutureTask:有返回值的多线程

常用的Thread类在run方法执行完之后是没有返回值的，要实现子线程完成任务后返回值给主线程需要借助第三方转存。Callable接口则提供了一种有返回值的多线程实现方法。下面以一个简单的地主、监工和长工的例子展示这种接口的用法。

长工类：

长工类实现了Callable接口，线程运行完成后返回一个Integer值。

import java.util.concurrent.Callable;

public class Changgong implements Callable<Integer>{

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

地主：主进程

监工：FutureTask

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


public class Dizhu {
        
    public static void main(String args[]){
        Changgong worker = new Changgong();
        FutureTask<Integer> jiangong = new FutureTask<Integer>(worker);
        new Thread(jiangong).start();
        while(!jiangong.isDone()){
            try {
                System.out.println("看长工做完了没...");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                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();
        }
        
        
    }
}

运行结果：

看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
I'm working......
看工人做完了没...
工作做完了,上交了12