您当前的位置： 首页 > 

Dongguo丶

暂无认证

  • 2浏览

    0关注

    472博文

    0收益

  • 0浏览

    0点赞

    0打赏

    0留言

私信
关注
热门博文

使用Callable接口创建线程

Dongguo丶 发布时间：2021-09-18 17:17:42 ，浏览量：2

创建线程的方法

一种是通过创建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 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 {

    @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

关注
打赏
1638062488
查看更多评论

最近更新

热门博客

[ 申请 ]友情链接：

ClashX教程 绘画宝宝 配音宝宝
立即登录/注册

微信扫码登录

0.0438s