java线程之——FutureTask

桃扇骨 2021-11-05 07:00 685阅读 0赞

一、FutureTask的实现

FutureTask实现了RunnableFuture，既即实现Runnable接口和Future接口。所以FutureTask实现run方法，以及Future接口的一系列计算结果方法

二、构造方法

FutureTask有两个构造方法，分别为一个参数和两个参数，如下图：

![20190808173104266.png][]

一个参数构造器传入一个Callable实现，需要返回参数；

第二个构造器第一个参数传入Runnable实现，不需要返回参数，但是需要再第二个参数指定返回值；

如下：

public static void test1() throws Exception {
        // FutureTask封装一个线程
        FutureTask<String> future = new FutureTask<>(() -> {
          System.out.println("work...");
          Thread.sleep(3000);
          throw new Exception("神奇");
          // return "工作完成";
        });
        // run运行线程,不会返回结果，线程异常不会被抛出，get时才会抛出异常
        future.run();
        // get等待任务执行完成，并返回结果
        System.out.println(future.get());
      }
    
      public static void test2() throws Exception {
        FutureTask<String> futureTask = new FutureTask<>(() -> System.out.println("work"), "OK");
        futureTask.run();
        System.out.println(futureTask.get());
      }

三、方法

1、run()：同线程的run方法，执行FutureTask的线程run方法，该方法不会抛出线程内部的异常。如果在之前FutureTask已被调用cancle方法取消，会抛出CancellationException。注意，FutureTask直接执行run方法，会阻塞等待线程执行完成，如下：

如果需要异步执行，需要用new Thread()去跑或者通过线程池执行，如下：

public static void testRun() throws Exception {
        FutureTask<String> future = new FutureTask<>(() -> {
          System.out.println("work...");
          Thread.sleep(5000);
          return "工作完成";
        });
        ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.submit(future);
        System.out.println("主线程不被阻塞");
        System.out.println(future.get());
        System.out.println("主线程阻塞，get等线程返回结果");
      }

2、cancle方法：尝试取消执行此任务，有一个布尔值的参数`mayInterruptIfRunning，此参数决定是否可以终止正在执行中的线程。`

*  `mayInterruptIfRunning为true，可以终止正在执行中的线程，返回true；`
    
        public static void testCancle() throws Exception {
            FutureTask<String> future = new FutureTask<>(() -> {
              System.out.println("work...");
              for (int i = 0; i < 10; i++) {
                Thread.sleep(1000);
                System.out.println(i);
              }
              System.out.println("工作完成!!!!");
              return "工作完成";
            });
            Thread thread = new Thread(future);
            thread.start();
            Thread.sleep(1000);
            System.out.println("取消正在执行的FutureTask");
            //true，会终止正在运行的线程
            System.out.println(future.cancel(true));
            System.out.println(future.isCancelled());
          }
    
     
 *  `mayInterruptIfRunning为false，不能终止正在执行中的线程，返回false；`
    
        public static void testCancle() throws Exception {
            FutureTask<String> future = new FutureTask<>(() -> {
              System.out.println("work...");
              for (int i = 0; i < 10; i++) {
                Thread.sleep(1000);
                System.out.println(i);
              }
              System.out.println("工作完成!!!!");
              return "工作完成";
            });
            Thread thread = new Thread(future);
            //false，如果线程已经开始执行，当前任务是不会被终止，但是仍然返回true
            System.out.println("取消还未执行的FutureTask");
            System.out.println(future.cancel(false));
            System.out.println(future.isCancelled());
            thread.start();
        }
 *  如果线程已被cancle，再次cancle将返回false；  
     
    
        public static void testCancle() throws Exception {
            FutureTask<String> future = new FutureTask<>(() -> {
              System.out.println("work...");
              Thread.sleep(5000);
              return "工作完成";
            });
            new Thread(future).start();
            System.out.println("取消正在执行的FutureTask");
            System.out.println(future.cancel(true));
            System.out.println(future.get());
          }

3、get方法：等待计算完成，然后检索其结果，这个方法会阻塞主线程，直到run执行完成并返回值。还可以设置最长等待时间，超过将抛出TimeoutException；计算引发异常抛出ExecutionException；当前线程在等待时中断抛出InterruptedException；计算被取消抛出CancellationException。

public static void testTimeoutException() throws Exception {
        FutureTask<String> future = new FutureTask<>(() -> {
          System.out.println("work...");
          Thread.sleep(5000);
          System.out.println("工作完成!!!!");
          return "工作完成";
        });
        new Thread(future).start();
        System.out.println(future.get(1, TimeUnit.SECONDS));
      }
    
      public static void testCancellationException() throws Exception {
        FutureTask<String> future = new FutureTask<>(() -> {
          System.out.println("work...");
          Thread.sleep(5000);
          System.out.println("工作完成!!!!");
          return "工作完成";
        });
        new Thread(future).start();
        Thread.sleep(1000);
        System.out.println(future.cancel(true));
        System.out.println(future.get(1, TimeUnit.SECONDS));
      }
    
      public static void testGetExecutionException() throws Exception {
        FutureTask<String> future = new FutureTask<>(() -> {
          System.out.println("work...");
          throw new Exception("出错啦");
        });
        new Thread(future).start();
        System.out.println(future.get());
      }
    
      public static void testInterruptedException() throws Exception {
        FutureTask<String> future = new FutureTask<>(() -> {
          System.out.println("work...");
          Thread.sleep(5000);
          return "工作完成";
        });
        Thread thread = new Thread(future);
        thread.start();
        thread.interrupt();
        System.out.println(future.get());
      }

[20190808173104266.png]: /images/20211104/df2277c4f2bf47348cc729e380315e12.png