Callable方式创建线程,并使用线程池异步执行任务

      线程的创建方式比较熟悉的是通过集成Runnable接口或者集成Thread类来实现,但是这两种方法都在线程执行完成后无法获取到执行结果,如果想异步执行某个任务并且执行完成之后需要知道他执行的结果的话可以使用Callable方式实现。

      例如创建一个ReadBookService类除了实现本身的业务接口外还实现Callable接口,Callable接口的异步执行方法是call()方法,这样就可以在call方法内部调用业务本身的方法来达到异步执行的效果。

public class ReadBookService implements IReadBookService, Callable<String> {

    private Map<String, Object> param;

    public ReadBookService(Map<String, Object> param) {
        this.param = param;
    }

    @Override
    public String readBook(String bookName) {
        System.out.println(bookName);
        return bookName;
    }

    @Override
    public String call() throws Exception {
        return readBook(Thread.currentThread().getName() + "正在阅读" + param.get("bookName").toString());
    }
}

在异步执行中获取最终的执行结果需要借助FutrueTask来完成,下面代码借助线程池来执行该方法

public class App {

    private static final ExecutorService executorService = new ThreadPoolExecutor(3, 6,
            5000L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20), new ThreadPoolExecutor.DiscardPolicy());

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Map<String, Object> param = new HashMap<>();
            param.put("bookName", "java" + i);
            FutureTask<String> futureTask = new FutureTask<>(new ReadBookService(param));
            executorService.submit(futureTask);
        }
    }
}

Callable接口实现类作为FutureTask的构造函数参数,同时把futureTask提交到executorService 中进行执行,代码到此仍然没有获取到异步执行的结果,如果需要获取到异步执行结果则需要通过futrueTask该对象,每一个线程都会对应一个futrueTask对象,就是通过futureTask该对象来获取执执行结果。

futureTask获取执行结果有:

1.futureTask.get()  该方法会一直阻塞直到运行完成结果返回;

2.futureTask.get(long timeout,TimeUnit unit)该方法在阻塞timeout时间后如果还未拿到结果则直接退出,防止线程阻塞时间过长。

如果需要获取结果则代码修改如下:

public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Map<String, Object> param = new HashMap<>();
            param.put("bookName", "java" + i);
            FutureTask<String> futureTask = new FutureTask<>(new ReadBookService(param));
            executorService.submit(futureTask);
            try {
                System.out.println("获取到结果值:"+futureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

但是如上代码仍然存在问题,由于futureTask.get() 是阻塞式等待结果返回,在每一次提交到线程池执行后就调用get()方法阻塞获取结果,这样获取方式仍然不是异步获取。进一步对代码进行修改,把每一个线程对应futrueTask对象暂存到一个list或者map中,这样在所有任务均已提交执行后再去获取执行结果,如下代码所示:

public class App {

    private static final ExecutorService executorService = new ThreadPoolExecutor(3, 6,
            5000L, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(20), new ThreadPoolExecutor.DiscardPolicy());

    private static List<FutureTask<String>> futureTaskList = new ArrayList<>();

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            Map<String, Object> param = new HashMap<>();
            param.put("bookName", "java" + i);
            FutureTask<String> futureTask = new FutureTask<>(new ReadBookService(param));
            executorService.submit(futureTask);
            futureTaskList.add(futureTask);
        }

        for (FutureTask<String> futureTask : futureTaskList) {
            try {
                System.out.println(futureTask.get());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
        
    }
}

这样任务的执行是并行执行,获取结果是阻塞式获取,则服务运行的最长时间是最后执行完结果返回的时间,如果其中一个线程执行完成需要花费10s,但是其余99个线程在1s就已经执行完成,则获取主线程阻塞的时间是10s,如果更巧的是那个花费10s的线程刚好放在list的第一位,则其余99个线程的结果也需要在第10s之后才能够获取到,显然这存在一定的优化空间。

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java中,可以使用多种方式创建线程异步执行任务。以下是一种常见的实现方式: 1. 使用Thread类:可以通过继承Thread类并重写run()方法来创建线程。在run()方法中定义需要异步执行任务。然后,创建Thread对象并调用start()方法启动线程。 示例代码如下: ```java class MyThread extends Thread { @Override public void run() { // 异步执行任务 System.out.println("异步任务开始执行"); // 执行其他操作... System.out.println("异步任务执行完毕"); } } public class Main { public static void main(String[] args) { MyThread thread = new MyThread(); thread.start(); // 执行其他操作... } } ``` 2. 使用Runnable接口:可以通过实现Runnable接口来创建线程。在实现的run()方法中定义需要异步执行任务。然后,创建Thread对象并将实现了Runnable接口的对象作为参数传递给Thread的构造函数。 示例代码如下: ```java class MyRunnable implements Runnable { @Override public void run() { // 异步执行任务 System.out.println("异步任务开始执行"); // 执行其他操作... System.out.println("异步任务执行完毕"); } } public class Main { public static void main(String[] args) { MyRunnable runnable = new MyRunnable(); Thread thread = new Thread(runnable); thread.start(); // 执行其他操作... } } ``` 以上是两种常见的创建线程异步执行任务方式。在实际应用中,还可以使用线程池Callable接口等方式来实现异步任务执行

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值