Callable实现多线程-蒲公英云

Callable实现多线程

运行下面的代码，我们会发现，I’m T….. 和 I’m T0…..会交替输出。通过下面的代码我们可以知道，这种方式相对于Runnable的实现方式，又更加灵活了，因为它可以将处理结果返回（即call方法是有返回值的）。这里顺便总结一下这种方式和实现Runnable接口的方式的区别：

1、Runnable接口复写的是run方法，而Callable接口复写的是call方法

2、Runnable只能将要执行的任务都封装在run()方法中，而Callable可以将执行结果返回。

3、Runnable复写了run()方法以后，如果发生异常，只能在run()方法中处理，换句话说，如果我们必须正确的谨慎的处理这个异常，否则可能会带来一些不必要的麻烦。但是Callable的call方法是可以抛出异常的。

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

public class CallableTest {

public static void main(String\[\] args) \{  
    T t = new T();  
    T0 t0 = new T0();  
    FutureTask<Integer> ft = new FutureTask<Integer>(t);  
    FutureTask<Integer> ft0 = new FutureTask<Integer>(t0);  
    new Thread(ft).start();  
    new Thread(ft0).start();  
    try \{  
        System.out.println("t....count" + ft.get());// ft.get()返回的是T类中call方法的处理结果  
        System.out.println("t0....count" + ft0.get());  
    \} catch (InterruptedException e) \{  
        e.printStackTrace();  
    \} catch (ExecutionException e) \{  
        e.printStackTrace();  
    \}  
\}

}
class T implements Callable{

@Override  
public Integer call() throws Exception \{  
    int count = Singleton.getInstance().count;  
    for (int i = 0; i < 100; i++) \{  
        count += i;  
        System.out.println("I'm T.....");  
    \}  
    return count;  
\}

}
class T0 implements Callable{

@Override  
public Integer call() throws Exception \{  
    int count = Singleton.getInstance().count;  
    for (int i = 0; i < 100; i++) \{  
        count -= i;  
        System.out.println("I'm T0.....");  
    \}  
    return count;  
\}

}

class Singleton{
protected Integer count = 0;
private Singleton(){}
private static Singleton sin = new Singleton();
public static Singleton getInstance(){
return sin;
}
}