Callable、Future、FutureTask在多线程中的应用场景

package com.Li.Callables;
import java.util.concurrent.Callable;
/**
 * @Description: Callable接口的实现类
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午7:18:09
 */
public class Callableimpl implements Callable<Integer> {
  @Override
  public Integer call() throws Exception {
    System.out.println("当前线程的名字："+Thread.currentThread().getName());
    return null;
  }
}
package com.Li.Callables
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * @Description:  
 * @auther:Li Ya Hui
 * @Time:2021年4月23日下午4:02:41
 */
public class Test {
  public static void main(String[] args) {
    //1.创建一个单线程化的线程池
    ExecutorService single = Executors.newSingleThreadExecutor();
    //2.callable 接口的实现类的实例化
    Callableimpl callableimpl = new Callableimpl();
    //3.将新创建的线程加入到线程池中
    single.submit(callableimpl);
  }
}

package com.Li.Callables;
import java.util.concurrent.Callable;
/**
 * @Description: Callable接口的实现类
 * @auther:Li Ya Hui
 * @Time:2021年4月22日下午7:18:09
 */
public class Callableimpl implements Callable<Integer> {
  //定义一个变量，用于承接线程任务执行之后的结果
  public int sum = 0;
  @Override
  //重写callable接口方法
  public Integer call() throws Exception {
    System.out.println("当前线程的名字："+Thread.currentThread().getName());
    System.out.println("通过实现callable接口的创建的多线程开始执行了");
    //模拟一个耗时的感觉
    Thread.sleep(1000);
    for (int i = 0; i < 100; i++) {
      sum+=i;
    }
    System.out.println("通过实现callable接口的创建的多线程结束执行了");
    return null;
  }
}
package com.Li.Callables;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * @Description:  测试通过callable+future实现多线程和获取结果
 * @auther:Li Ya Hui
 * @Time:2021年4月23日下午4:02:41
 */
public class Test {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
    //1.创建一个单线程化的线程池
    ExecutorService single = Executors.newSingleThreadExecutor();
//    ExecutorService single = Executors.newFixedThreadPool(5);
//    ExecutorService single = Executors.newSingleThreadExecutor();
//    ExecutorService single = Executors.newScheduledThreadPool(1);
    //2.callable 接口的实现类的实例化
    Callableimpl callableimpl = new Callableimpl();
    //3.将新创建的线程加入到线程池中
    //single.submit(callableimpl);
    Future<Integer> future = single.submit(callableimpl);
    //4.关闭线程池
    single.shutdown();
    if(single.isShutdown()) 
    {     
      System.out.println("线程池已关闭");
    }
    //模拟主函数还存在
    Thread.sleep(3000);
    System.out.println("主函数线程还存在");
    //5.取出新的线程执行完之后的结果 
    if ((future.get())!=null)
    {     
      System.out.println(future.get()); 
    }else 
    {
      System.out.println("future.get()获取到的结果为null");
    }
    if(future.isDone()) 
    {
      System.out.println("线程池中的任务已经完成！");
    }
    System.out.println("主函数线程结束了");
  }
}

package com.Li.Callables;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
/**
 * @Description:  callable的实现类    callable+future实现多线程，和获取结果和抛出异常
 * @auther:Li Ya Hui
 * @Time:2021年4月23日下午8:21:58
 */ 
public class Callable02  implements Callable<String>{
  //定义一个变量用来表示现成的不同用途
  public int flag;
  //构造方法 传flag
  public Callable02(int a ) {
    super();
    this.flag =  a;
  }
  @Override
  public String call() throws Exception {
    //三种运行任务 第一种正常
    if (flag == 0) 
    {
      return "flag == 0";
    }
    //三种运行任务 第二种死循环
    if (flag == 1 ) 
    {
      try {
        while (true) {
          System.out.println("死循环.....");
          Thread.sleep(2000);
        }
      } catch (InterruptedException e) {
        System.out.println("中断异常");
      }
      return "false ";
    }
    //三种运行任务 第三种会报错
    else 
    {
      throw new Exception("输入有误");
    }
  }
}
package com.Li.Callables;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * @Description:  测试类，测试callable+future 实现多线程和获取结果，抛出异常
 * @auther:Li Ya Hui
 * @Time:2021年4月23日下午9:18:47
 */
public class Test02 {
  public static void main(String[] args) throws InterruptedException, ExecutionException {
    //1.创建三个新的线程
    Callable02 task1= new Callable02(0);
    Callable02 task2 = new Callable02(1);
    Callable02 task3 = new Callable02(2);
    //2.创建线程池
    ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
    //3.将这三个线程逐次装入线程池中
    Future<String> future = fixedThreadPool.submit(task1);
    System.out.println(future.get());
    Future<String> future2 = fixedThreadPool.submit(task2);
//    System.out.println(future2.get());// 不能获取返回值，因为会造成一直等待结果，线程堵塞
    //假定5秒钟之后  结束任务2
    Thread.sleep(5000);
    future2.cancel(true);//直接取消线程任务（TRUE）  正常执行
    System.out.println(future2);
    //如果报错，catch
    try {
      Future<String> future3 = fixedThreadPool.submit(task3);
      System.out.println(future3.get());
    } catch (Exception e) {
      System.out.println(e.getMessage());
    }
    //关闭线程池
    fixedThreadPool.shutdown();
  }
}