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<Integer>{

    @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<Integer>{
    
    @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;
    }
}