Java 实现Callable接口的方式创建线程

NaN

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

/**
 * @description 用实现Callable接口的方式实现进程的执行
 * @create 2022-01-21 9:36
 */

class NumIncrease implements Callable {

    private int sum = 0;

    @Override
    public Object call() throws Exception {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
            sum += i;
        }
        return sum;
    }
}

public class ThreadTest_3 {
    public static void main(String[] args) {
        NumIncrease numIncrease = new NumIncrease();

        /**
         * Future接口：
         *      > 可以对具体的Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
         *      > FutureTask是Future接口的唯一的实现子类
         *      > FutureTask同时实现了Runnable、Future接口，它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
         */

        FutureTask futureTask = new FutureTask(numIncrease);
        //新建线程用于执行NumIncrease里的call()
        new Thread(futureTask).start();
        
        try {
            Object sum = futureTask.get(); //得到call()的返回值内容
            System.out.println("sum=" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

其中一个执行过程：

1
2
3
4
5
6
7
8
9
10
sum=55

Process finished with exit code 0

NaN

另一个案例

public class CallableDemo {

    public static void main(String[] args) {
        Callable<Long> callable = new MyThread();
        FutureTask<Long> future = new FutureTask<>(callable);
        new Thread(future, "Callable 线程").start();
        try {
            System.out.println("任务耗时：" + (future.get() / 1000000) + "毫秒");
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }

    static class MyThread implements Callable<Long> {

        private int ticket = 10000;

        @Override
        public Long call() {
            long begin = System.nanoTime();
            while (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + " 卖出了第 " + ticket + " 张票");
                ticket--;
            }

            long end = System.nanoTime();
            return (end - begin);
        }

    }

}

总结：通过实现 Callable 接口创建线程的步骤如下

1）创建 Callable 接口的实现类，并实现 call 方法。该 call 方法将作为线程执行体，并且有返回值。

2）创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call 方法的返回值。

3）使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。

4）调用 FutureTask 对象的 get 方法来获得线程执行结束后的返回值。