使用Callable接口创建线程

野性酷女 2022-09-12 01:57 398阅读 0赞

# **创建线程的方法** #

一种是通过创建Thread类，另一种是通过使用Runnable创建线程。但是，Runnable缺少的一项功能是，当线程终止时（即run（）完成时），我们无法使线程返回结果。为了支持此功能，Java中提供了Callable接口。

当然了还可以使用线程池创建线程。

# **Callable接口和Runnable接口的区别** #

Callable接口中定义了需要有返回的任务需要实现的call方法。

比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后，  
主线程就去做其他事情了，过了一会才去获取子任务的执行结果。

class MyThread implements Runnable { 
    
        @Override
        public void run() { 
    
        }
    }
    
    class MyThread2 implements Callable { 
        
        @Override
        public Object call() throws Exception { 
            return null;
        }
    }

• 为了实现Runnable，需要实现不返回任何内容的run（）方法，而对于Callable，需要实现在完成时返回结果的call（）方法。

• call（）方法可以引发异常，而run（）则不能。

• 为实现Callable而必须重写call方法

• Callable不能直接替换Runnable,因为Thread类的构造方法根本没有Callable

Thread() 可以传Runnable接口不能传Callable接口

所以要找同时满足Runnable接口和 Callable接口的实现

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eBh2Uacr-1631956607498)(E:\\笔记\\图片\\image\\07Callable接口.assets\\image-20210904070823338.png)\]

public FutureTask(Callable<V> callable) { 
            if (callable == null)
                throw new NullPointerException();
            this.callable = callable;
            this.state = NEW;       // ensure visibility of callable
        }
    
        public FutureTask(Runnable runnable, V result) { 
            this.callable = Executors.callable(runnable, result);
            this.state = NEW;       // ensure visibility of callable
        }

# **Future接口** #

Future接口定义了操作异步任务执行一些方法，如获取异步任务的执行结果、取消任务的执行、判断任务是否被取消、判断任务执行是否完毕等。

当call（）方法完成时，结果必须存储在主线程已知的对象中，以便主线程可以知道该线程返回的结果。为此，可以使用Future对象。

将Future视为保存结果的对象–它可能暂时不保存结果，但将来会保存（一旦Callable返回）。Future基本上是主线程可以跟踪进度以及其他线程的结果的一种方式。要实现此接口，必须重写5种方法，这里列出了重要的方法,如下:

• public boolean cancel（boolean mayInterrupt）：用于停止任务。

如果尚未启动，它将停止任务。如果已启动，则仅在mayInterrupt为true时才会中断任务。

• public Object get（）抛出InterruptedException，ExecutionException：用于获取任务的结果。

如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

• public boolean isDone（）：如果任务完成，则返回true，否则返回false

可以看到Callable和Future做两件事-Callable与Runnable类似，因为它封装了要在另一个线程上运行的任务，而Future用于存储从另一个线程获得的结果。实际上，future也可以与Runnable一起使用。

要创建线程，需要Runnable。为了获得结果，需要future。

# **FutureTask** #

Java库具有具体的FutureTask类型，该类型实现Runnable和Future，并方便地将两种功能组合在一起。 可以通过为其构造函数提供Callable来创建FutureTask。然后，将FutureTask对象提供给Thread的构造函数以创建Thread对象。因此，间接地使用Callable创建线程。

核心原理:(重点)

在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成

• 当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态

一般FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果。

• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法

• 一旦计算完成，就不能再重新开始或取消计算

• get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常

• get只计算一次,因此get方法放到最后

# Callable创建线程 #

通过FutureTask的构造函数提供Callable来创建FutureTask。然后，将FutureTask对象提供给Thread的构造函数以创建Thread对象。间接地使用Callable创建线程。

package com.dongguo.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /** * @author Dongguo * @date 2021/9/4 0004-7:10 * @description: Callable创建线程 */
    public class CallableDemo { 
        public static void main(String[] args) { 
            try { 
                FutureTask task = new FutureTask(new MyThread());
                new Thread(task, "t1").start();
                System.out.println(task.get());
    
                //Lambda表达式
                FutureTask task2 = new FutureTask(()->{ 
                    System.out.println("Lambda表达式 Callable创建线程");
                    return 20;
                });
                new Thread(task2,"t2").start();
                System.out.println(task2.get());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }
    
    class MyThread implements Callable<Integer> { 
    
        @Override
        public Integer call() throws Exception { 
            System.out.println("Callable创建线程");
            return 200;
        }
    }
    运行结果：
    Callable创建线程
    200
    Lambda表达式 Callable创建线程
    20

## get阻塞 ##

• public Object get（）抛出InterruptedException，ExecutionException：用于获取任务的结果。

如果任务完成，它将立即返回结果，否则将等待任务完成，然后返回结果。

一旦调用get()方法，计算完成前都会导致阻塞

package com.dongguo.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.TimeUnit;
    
    /** * @author Dongguo * @date 2021/9/4 0004-7:10 * @description: Callable创建线程 */
    public class CallableDemo { 
        public static void main(String[] args) { 
            try { 
                //Lambda表达式
                FutureTask task2 = new FutureTask(()->{ 
                    TimeUnit.SECONDS.sleep(4);//睡眠4s
                    System.out.println("Lambda表达式 Callable创建线程");
                    return 20;
                });
                new Thread(task2,"t2").start();
                System.out.println(task2.get());//输出语句1
                System.out.println(Thread.currentThread().getName()+"计算完成");//输出语句2
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }
    运行结果：
    Lambda表达式 Callable创建线程
    20
    main计算完成

task2.get()输出语句1在输出语句2之前，运行结果等待4秒后才获得get返回的值，然后再打印输出语句2

package com.dongguo.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.TimeUnit;
    
    /** * @author Dongguo * @date 2021/9/4 0004-7:10 * @description: Callable创建线程 */
    public class CallableDemo { 
        public static void main(String[] args) { 
            try { 
                //Lambda表达式
                FutureTask task2 = new FutureTask(()->{ 
                    TimeUnit.SECONDS.sleep(4);//睡眠4s
                    System.out.println("Lambda表达式 Callable创建线程");
                    return 20;
                });
                new Thread(task2,"t2").start();
                System.out.println(Thread.currentThread().getName()+"计算完成");//输出语句2
                System.out.println(task2.get());//输出语句1
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }
    运行结果
    main计算完成
    Lambda表达式 Callable创建线程
    20

输出语句1位于输出语句2之后，运算结果直接打印输出语句2，等待4秒后再输出get结果

所以get()方法一般放在最后位置

一般推荐使用task2.get(time) 有超时时间的

## 多个线程使用同一个FutureTask， get方法返回几次打印 ##

package com.dongguo.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.TimeUnit;
    
    /** * @author Dongguo * @date 2021/9/4 0004-7:10 * @description: Callable创建线程 */
    public class CallableDemo { 
        public static void main(String[] args) { 
            try { 
                //Lambda表达式
                FutureTask task2 = new FutureTask(()->{ 
                    TimeUnit.SECONDS.sleep(4);//睡眠4s
                    System.out.println("Lambda表达式 Callable创建线程");
                    return 20;
                });
                new Thread(task2,"t2").start();
                new Thread(task2,"t1").start();
                System.out.println(Thread.currentThread().getName()+"计算完成");
                System.out.println(task2.get());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }
    运行结果
    main计算完成
    Lambda表达式 Callable创建线程
    20

多个线程使用同一个FutureTask，get方法只返回一次结果

## 多次调用get方法 ##

package com.dongguo.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.TimeUnit;
    
    /** * @author Dongguo * @date 2021/9/4 0004-7:10 * @description: Callable创建线程 */
    public class CallableDemo { 
        public static void main(String[] args) { 
            try { 
                //Lambda表达式
                FutureTask task2 = new FutureTask(()->{ 
                    TimeUnit.SECONDS.sleep(4);//睡眠4s
                    System.out.println("Lambda表达式 Callable创建线程");
                    return 20;
                });
                new Thread(task2,"t2").start();
                System.out.println(Thread.currentThread().getName()+"计算完成");
                System.out.println(task2.get());
                System.out.println(task2.get());
                System.out.println(task2.get());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }
    运行结果
    main计算完成
    Lambda表达式 Callable创建线程
    20
    20
    20

多次调用get方法，输出语句打印1次，只计算一次，多次直接返回结果

## isDone轮询方式代替阻塞 ##

• public boolean isDone（）：如果任务完成，则返回true，否则返回false

轮询的方式会耗费无谓的CPU资源，而且也不见得能及时地得到计算结果.

如果想要异步获取结果,通常都会以轮询的方式去获取结果  
尽量不要阻塞

package com.dongguo.callable;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    import java.util.concurrent.TimeUnit;
    
    /** * @author Dongguo * @date 2021/9/4 0004-7:10 * @description: Callable创建线程 */
    public class CallableDemo { 
        public static void main(String[] args) { 
            try { 
                //Lambda表达式
                FutureTask task2 = new FutureTask(()->{ 
                    TimeUnit.SECONDS.sleep(4);//睡眠4s
                    System.out.println("Lambda表达式 Callable创建线程");
                    return 20;
                });
                new Thread(task2,"t2").start();
                while (!task2.isDone()){ 
                  	System.out.println("任务 未完成");
                }
                System.out.println(Thread.currentThread().getName()+"计算完成");
                System.out.println(task2.get());
            } catch (InterruptedException e) { 
                e.printStackTrace();
            } catch (ExecutionException e) { 
                e.printStackTrace();
            }
        }
    }
    运行结果
      ...
    任务 未完成
    任务 未完成
    任务 未完成
    Lambda表达式 Callable创建线程
    任务 未完成
    main计算完成
    20

循环判断任务是否完成，知道睡眠4秒任务才完成

# 总结 #

• 在主线程中需要执行比较耗时的操作时，但又不想阻塞主线程时，可以把这些作业交给Future对象在后台完成, 当主线程将来需要时，就可以通过Future对象获得后台作业的计算结果或者执行状态

• 一般FutureTask多用于耗时的计算，主线程可以在完成自己的任务后，再去获取结果

• 仅在计算完成时才能检索结果；如果计算尚未完成，则阻塞 get 方法。一旦计算完成，就不能再重新开始或取消计算。get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。

# 对于一些复杂的场景 #

应对Future的完成时间，完成了可以直接告诉我，也就是回调通知

将两个异步计算合成一个异步计算，这两个异步计算互相独立，同时第二个又依赖第一个的结果。

当Future集合中某个任务最快结束时，返回结果。

等待Future结合中的所有任务都完成。

以上这些场景Future无法完成，需要使用到CompletableFuture