JavaSE---多线程---Callable、Future

1、概述

　　　　1.1　　JDK1.5后，Java提供了Callable接口，该接口提供  一个call方法   作为  线程执行体，该call方法可以  有返回值、声明抛出异常；

　　　　　　　　　　因此，我们可以直接将Callable接口作为target来创建线程，但是：Callable接口是新增的接口，不是Runnable的实现类；

　　　　　　　           JDK1.5后   又 提供了Future接口 代表  Callable接口的call()的  返回值，

　　　　　　　　　　　　　　　　并提供  Future接口的实现类FutureTask（该类实现了Runnable接口、Futrure接口，可以   作为Thread的target）；

　　　　1.2　　创建、启动有返回值的线程：

　　　　　　　　　　1.2.1　　创建Callable接口的实现类，实现call方法；

　　　　　　　　　　1.2.2　　创建实现类的实例，并用FutureTask进行封装；

　　　　　　　　　　1.2.3　　使用FutureTask的实例作为Thread的target创建Thread实例、调用start()开启线程；

　　　　　　　　　　1.2.4　　调用FutureTask实例的方法来获得子线程执行后的返回值；

package com.an;

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

public class CallableImpl implements Callable {
    /**
     * 线程执行体
     * @return
     * @throws Exception
     */
    public Object call() throws Exception {
        int i=0;
        for (;i<10;i++){

        }
        return i;
    }

    public static void main(String[] args)throws Exception{
        for (int i=0;i<30;i++){
            System.out.println(Thread.currentThread().getName()+"="+i);
            if (i==5){
                FutureTask futureTask=new FutureTask(new CallableImpl());
                Thread thread=new Thread(futureTask,"有返回值的线程");
                thread.start();
                thread.join();
                System.out.println(futureTask.get());
            }
        }

    }
}

　　　　1.3、FutureAPI

　　　　　　　　

　　　　1.4、实战

package com.an.thread.callable;

import java.util.concurrent.Callable;

/**
 * @description:
 * @author: anpeiyong
 * @date: Created in 2020/1/18 10:33
 * @since:
 */
public class MyTask implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("线程执行开始...");
        int i=1/0;
        return 1;
    }
}

　　

package com.an.thread.callableandfuture;

import java.util.concurrent.*;

/**
 * @description:
 * @author: anpeiyong
 * @date: Created in 2020/1/18 10:34
 * @since:
 */
public class Test {

    public static void main(String[] args) {

//        testManThread();
        testThreadPool();
    }

    /**
     * 手动创建线程
     */
    public static void testManThread(){
        FutureTask<Integer> futureTask=new FutureTask<>(new MyTask());
        new Thread(futureTask).start();
        try {
            int a=(Integer) futureTask.get();
            System.out.println(a);
        }catch (Exception e){
            System.out.println("异常了："+e);
        }
    }

    /**
     * 线程池使用
     *
     */
    public static void testThreadPool(){
        ThreadPoolExecutor executor=new ThreadPoolExecutor(10,10,20, TimeUnit.SECONDS,new ArrayBlockingQueue<>(10));
        //-----------------第一种：自定义任务、线程池提交任务
        // executor.submit()   只需要提交任务即可，无需FutureTask封装
//        Future<Integer> future=executor.submit(new MyTask());

        //-----------------第二种：不用自定义任务、线程池通过内部类提交任务
        Future future=executor.submit(()->{
            System.out.println("线程执行开始...");
            int i=1/0;
            return 1;
        });
        try {
            int a=(Integer) future.get();
            System.out.println(a);
        }catch (Exception e){
            System.out.println("异常了："+e);
        }finally {
            executor.shutdown();
        }

    }
}