Java并发编程—说说Runnable与Callable

原文作者：每天一点

原文地址：说说Runnable与Callable

首先，我们先看看使用Callable创建线程与使用Runable的区别：

import java.util.concurrent.Callable;

//实现Runable
class MyThread implements Runnable {

    @Override
    public void run() {
        
    }
}

//实现Callable
class MyThread1 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        return null;
    }
}

首先，实现Callable而重写的方法具有返回值，并且拥有泛型，这提高了线程的细粒度。

实现Runable接口创建线程方式：

//实现Runable创建线程的方式
MyThread myThread = new MyThread();
Thread thread = new Thread(myThread);

实现Callable接口创建线程方式

查阅API我们可以发现，在Thread的构造方法中并没有使用Callable作为参数的构造器。解决办法：我们先查看Runable接口，

可以发现有一个FutureTask的实现类，点进这个实现类，我们可以发现在这个类的构造方法中就可以传Callable对象

所以我们可以借助FutureTask这个类，具体创建代码如下：

//实现Callable创建线程的方式
FutureTask futureTask = new FutureTask(new MyThread1());
Thread thread1 = new Thread(futureTask);

这里有个细节：如果我们在使线程睡眠5秒钟，然后使用futureTask.get()方法，会发现结果会等5秒才出现，说明get()方法是有阻塞效果

//实现Callable
class MyThread1 implements Callable<Integer> {

    @Override
    public Integer call() throws Exception {
        System.out.println("进入方法中");
        Thread.sleep(5000);
        return 1000;
    }
}

public class Test {
    public static void main(String[] args) {
        //实现Callable创建线程的方式
        FutureTask futureTask = new FutureTask(new MyThread1());
        new Thread(futureTask, "AAA").start();
        try {
            System.out.println(futureTask.get());
            System.out.println("main");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

并且只执行了一次，因为一个futureTask，不管几个线程调用，调用的都是同一个futureTask对象

Callable接口：

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

Runnable接口：

public interface Runnable {
    public abstract void run();
}

相同点：

1. 两者都是接口；（废话）
2. 两者都可用来编写多线程程序；
3. 两者都需要调用Thread.start()启动线程；

不同点：

1. 两者最大的不同点是：实现Callable接口的任务线程能返回执行结果；而实现Runnable接口的任务线程不能返回结果；
2. Callable接口的call()方法允许抛出异常；而Runnable接口的run()方法的异常只能在内部消化，不能继续上抛；

注意点：

• Callable接口支持返回执行结果，此时需要调用FutureTask.get()方法实现，此方法会阻塞主线程直到获取‘将来’结果；当不调用此方法时，主线程不会阻塞！

写此篇的原因是一次面试中问到Callable与Runnable的区别，当时用的多的是Runnable，而Callable使用很少！比较了两者后（网上查了不少），发现Callable在很多特殊的场景下还是很有用的！最后留点抄的代码，加深对Callable的认识！

package com.inte.fork;
import java.util.*;
import java.util.concurrent.*;
import static java.util.Arrays.asList;

public class Sums {

    static class Sum implements Callable<Long> {
        private final long from;
        private final long to;

        Sum(long from, long to) {
            this.from = from;
            this.to = to;
        }

        @Override
        public Long call() {
            long acc = 0;
            for (long i = from; i <= to; i++) {
                acc = acc + i;
            }
            System.out.println(Thread.currentThread().getName() + " : " + acc);
            return acc;
        }
    }

    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newFixedThreadPool(3);
        List<Future<Long>> results = executor.invokeAll(asList(
                new Sum(0, 10), new Sum(0, 1_000), new Sum(0, 1_000_000)
        ));
        executor.shutdown();

        for (Future<Long> result : results) {
            System.out.println(result.get());
        }
    }
}