浅谈Callable接口

前言

---

犹记当年面试的时候，被问过一个问题，

“实现多线程的方式有几种呀？”

“两种”

“哪两种？”

“实现Runnable接口和继承Thread类”

“是的，还有没有其他方式呢？”

“记得还有一个什么接口，具体怎么用的忘记了”

“Callable”

这就来说说Callable吧。

这个接口为什么会出现

---

场景一

我们先回想一下，我们实现Runnable接口创建多线程的时候，怎么做的吧？

/*
    打印从1到100的数
*/
package com.pochi.juc;

public class CallableProblem1 {
    public static void main(String[] args) {
        CallableDemo1 callableDemo1 = new CallableDemo1();
        new Thread(callableDemo1).start();
    }
}

class CallableDemo1 implements  Runnable{


    @Override
    public void run() {
        for(int i=0;i<100;i++){
            System.out.println(i+1);
        }
    }
}

场景二

产品过来提需求了，不要打印1-100，要打印和了。

你一想，简单！

package com.pochi.juc;



public class CallableProblem1 {
    public static void main(String[] args) {
        CallableDemo1 callableDemo1 = new CallableDemo1();
        Thread thread = new Thread(callableDemo1);
        thread.start();

        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(callableDemo1.sum);
    }
}

class CallableDemo1 implements  Runnable{
    int sum=0;

    @Override
    public void run() {
        for(int i=0;i<100;i++){
            sum+=i+1;
        }
    }
}

以上的代码看起来好像可以，但是漏洞不少，多线程的时候操作sum，原子性不能保证吧？

好好好，那就atomic类呗~

对的，但是，越处理，你不会觉得这一切本可以不用那么麻烦吗？这一切问题出现的原因是run这个函数是个void类型，所以，没法返回值。我们一般在单线程程序里面都是运算完，通过返回值返回回去吧？正是这个需求，促使Callable的出现。

简单来说

实现Callable接口和实现Runnable接口实现创建多线程的区别就在于，能不能返回值，需不需要返回值。需要返回值的，最好使用Callable接口。

先看看Callable这种方法是怎么操作的，再下判断吧~

实现Callable接口创建线程

---

package com.pochi.juc;

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

public class CallableProblem2 {
    public static void main(String[] args) {
        CallableDemo2 callableDemo2 = new CallableDemo2();
        FutureTask<Integer> integerFutureTask = new FutureTask<Integer>(callableDemo2);
        new Thread(integerFutureTask).start();

        try {
            Integer integer = integerFutureTask.get();
            System.out.println(integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

// 泛型是返回值类型
class CallableDemo2 implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum=0;
        for(int i=0;i<100;i++){
            sum+=i+1;
        }
        return sum;

    }
}

反正，用就是这么用，Integer可以换成其他的类型。有一个点，需要注意，其实

Integer integer = integerFutureTask.get();

这个肯定是阻塞的，不然的话，那边都还没加完，我这边是不可能get出东西的，这点需要注意。

这样一来，新开辟的那个线程就好好做自己的事儿，做完了，把值返回回来就好了，结构更规整。

后记

---

下次面试，这个Callable你会用了吗？