Java并发编程Callable与Future的应用实例代码

本文主要探究的是java并发编程callable与future的使用，分享了相关实例代码，具体介绍如下。

我们都知道实现多线程有2种方式，一种是继承Thread，一种是实现Runnable，但这2种方式都有一个缺陷，在任务完成后无法获取返回结果。要想获得返回结果，就得使用Callable，Callable任务可以有返回值，但是没法直接从Callable任务里获取返回值；想要获取Callabel任务的返回值，需要用到Future。所以Callable任务和Future模式，通常结合起来使用。

试想一个场景：需要一个帖子列表接口，除了需要返回帖子列表之外，还需要返回每条帖子的点赞列表和评论列表。一页10条帖子来计算，这个接口需要访问21次数据库，访问一次数据库按100ms计算，21次，累计时间为2.1s。这个响应时间，怕是无法令人满意的。怎么办呢？异步化改造接口。

查出帖子列表后，迭代帖子列表，在循环里起10个线程，并发去获取每条帖子的点赞列表，同时另起10个线程，并发去获取每条帖子的评论列表。这样改造之后，接口的响应时间大大缩短，在200ms。这个时候就要用Callabel结合Future来实现。

private List<PostResponse> createPostResponseList(Page<PostResponse> page,final String userId){
    if(page.getCount()==0||page==null||page.getList()==null){
      return null;
    }
    //获取帖子列表
    List<PostResponse> circleResponseList = page.getList();
    int size=circleResponseList.size();
    ExecutorService commentPool = Executors.newFixedThreadPool(size);
    ExecutorService supportPool = Executors.newFixedThreadPool(size);
    try {
      List<Future> commentFutureList = new ArrayList<Future>(size);
      if (circleResponseList != null && circleResponseList.size() > 0) {
        for (PostResponse postResponse : circleResponseList) {
          final String circleId=postResponse.getId();
          final String postUserId=postResponse.getUserId();
          //查评论列表
          Callable<List<CircleReviews>> callableComment = new Callable<List<CircleReviews>>() {
            @Override
            public List<CircleReviews> call() throws Exception {
              return circleReviewsBiz.getPostComments(circleId);
            }
          };
          Future f = commentPool.submit(callableComment);
          commentFutureList.add(f);
          //查点赞列表
          Callable<List<CircleZan>> callableSupport = new Callable<List<CircleZan>>() {
            @Override
            public List<CircleZan> call() throws Exception {
              return circleZanBiz.findList(circleId);
            }
          };
          Future supportFuture = supportPool.submit(callableSupport);
          commentFutureList.add(supportFuture);
        } 

      }
      // 获取所有并发任务的执行结果
      int i = 0;
      PostResponse temp = null;
      for (Future f : commentFutureList) {
        temp = circleResponseList.get(i);
        temp.setCommentList((List<CircleReviews>) f.get();
        temp.setSupportList((List<CircleZan>) f.get();
        circleResponseList.set(i, temp);
        i++;
      } 

    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      // 关闭线程池
      commentPool.shutdown();
      supportPool.shutdown();
    }
    return circleResponseList;
}

总结

以上就是本文关于Java并发编程Callable与Future的应用实例代码的全部内容，希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题，如有不足之处，欢迎留言指出。感谢朋友们对本站的支持！

赞 (0)

相关推荐

  • java多线程返回值使用示例(callable与futuretask)

    Callable接口类似于Runnable,从名字就可以看出来了,但是Runnable不会返回结果,并且无法抛出返回结果的异常,而Callable功能更强大一些,被线程执行后,可以返回值,这个返回值可以被Future拿到,也就是说,Future可以拿到异步执行任务的返回值,下面来看一个简单的例子 复制代码 代码如下: package com.future.test; import java.io.FileNotFoundException;import java.io.IOException;i

  • java多线程Future和Callable类示例分享

    一,描写叙述 ​在多线程下编程的时候.大家可能会遇到一种需求,就是我想在我开启的线程都结束时,同一时候获取每一个线程中返回的数据然后再做统一处理,在这种需求下,Future与Callable的组合就派上了非常大的用场. 也有人会说,我能够使用同步来完毕这个需求啊,普通情况下确实能够.可是在一种特殊情况下就不行了: ​想象,你开启了多个线程同步计算一些数据,可是大家都知道,线程是会争用资源的,也就是说.你开启多个线程来同步计算数据时.事实上线程之间的计算顺序是不可空的,当然除非你非非常大周折去处理

  • Java中的Runnable，Callable，Future，FutureTask的比较

    Java中的Runnable,Callable,Future,FutureTask的比较 Java中存在Runnable.Callable.Future.FutureTask这几个与线程相关的类或者接口,在Java中也是比较重要的几个概念,我们通过下面的简单示例来了解一下它们的作用于区别. Runnable 其中Runnable应该是我们最熟悉的接口,它只有一个run()函数,用于将耗时操作写在其中, 该函数没有返回值 .然后使用某个线程去执行该runnable即可实现多线程,Thread类在调

  • Java concurrency线程池之Callable和Future_动力节点Java学院整理

    Java concurrency线程池之Callable和Future_动力节点Java学院整理

    Callable 和 Future 简介 Callable 和 Future 是比较有趣的一对组合.当我们需要获取线程的执行结果时,就需要用到它们.Callable用于产生结果,Future用于获取结果. 1. Callable Callable 是一个接口,它只包含一个call()方法.Callable是一个返回结果并且可能抛出异常的任务. 为了便于理解,我们可以将Callable比作一个Runnable接口,而Callable的call()方法则类似于Runnable的run()方法. Ca

  • java自定义任务类定时执行任务示例 callable和future接口使用方法

    Callable 和 Future接口Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务. Callable和Runnable有几点不同: (1)Callable规定的方法是call(),而Runnable规定的方法是run().(2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值的. (3)call()方法可抛出异常,而run()方法是不能抛出异常的.(4)运行Callable任务可拿到一

  • 浅谈在Java中使用Callable、Future进行并行编程

    使用Callable.Future进行并行编程 在Java中进行并行编程最常用的方式是继承Thread类或者实现Runnable接口.这两种方式的缺点是在任务完成后无法直接获取执行结果,必须通过共享变量或线程间通信,使用起来很不方便. 从Java1.5开始提供了Callable和Future两个接口,通过使用它们可以在任务执行完毕后得到执行结果. 下面我们来学习下如何使用Callable.Future和FutureTask. Callable接口 Callable接口位于java.util.co

  • java Callable与Future的详解及实例

    java  Callable与Future Callable与 Future 两功能是Java在后续版本中为了适应多并法才加入的,Callable是类似于Runnable的接口,实现Callable接口的类和实现Runnable的类都是可被其他线程执行的任务. Callable的接口定义如下: public interface Callable<V> { V call() throws Exception; <span id="transmark"></s

  • Java并发编程Callable与Future的应用实例代码

    本文主要探究的是java并发编程callable与future的使用,分享了相关实例代码,具体介绍如下. 我们都知道实现多线程有2种方式,一种是继承Thread,一种是实现Runnable,但这2种方式都有一个缺陷,在任务完成后无法获取返回结果.要想获得返回结果,就得使用Callable,Callable任务可以有返回值,但是没法直接从Callable任务里获取返回值:想要获取Callabel任务的返回值,需要用到Future.所以Callable任务和Future模式,通常结合起来使用. 试想

  • Java并发编程必备之Future机制

    Java并发编程必备之Future机制

    前言 Java 5在concurrency包中引入了java.util.concurrent.Callable 接口,它和Runnable接口很相似,但它可以返回一个对象或者抛出一个异常. Callable接口使用泛型去定义它的返回类型.Executors类提供了一些有用的方法在线程池中执行Callable内的任务.由于Callable任务是并行的,我们必须等待它返回的结果.而线程是属于异步计算模型,所以不可能直接从别的线程中得到函数返回值. java.util.concurrent.Futur

  • Java 并发编程中如何创建线程

    简介 线程是基本的调度单位,它被包含在进程之中,是进程中的实际运作单位,它本身是不会独立存在.一个进程至少有一个线程,进程中的多个线程共享进程的资源. Java中创建线程的方式有多种如继承Thread类.实现Runnable接口.实现Callable接口以及使用线程池的方式,线程池将在后面文章中单独介绍,这里先介绍另外三种方式. 继承Thread类 优点:在run方法里可以用this获取到当前线程. 缺点:由于Java不支持多继承,所以如果继承了Thread类后就不能再继承其他类. public

  • Java并发编程之线程之间的共享和协作

    Java并发编程之线程之间的共享和协作

    一.线程间的共享 1.1 ynchronized内置锁 用处 Java支持多个线程同时访问一个对象或者对象的成员变量 关键字synchronized可以修饰方法或者以同步块的形式来进行使用 它主要确保多个线程在同一个时刻,只能有一个线程处于方法或者同步块中 它保证了线程对变量访问的可见性和排他性(原子性.可见性.有序性),又称为内置锁机制. 对象锁和类锁 对象锁是用于对象实例方法,或者一个对象实例上的 类锁是用于类的静态方法或者一个类的class对象上的 类的对象实例可以有很多个,但是每个类只有

  • Java并发编程之线程创建介绍

    目录 1.线程与进程 2.线程的创建与运行 1.线程与进程 进程是代码在数据集合上的一次运行活动,是系统进行资源分配和调度的基本单位,线程则是一个实体,一个进程中至少有一个线程,是CPU调度和分配的基本单位,进程中的多个线程共享进程的资源. 进程的三个特征: 动态性 : 进程是运行中的程序,要动态的占用内存,CPU和网络等资源. 独立性 : 进程与进程之间是相互独立的,彼此有自己的独立内存区域. 并发性 : 假如CPU是单核,同一个时刻其实内存中只有一个进程在被执行.CPU会分时轮询切换依次为每

  • Java并发编程同步器CountDownLatch

    Java并发编程同步器CountDownLatch

    CountDownLatch 在日常开发中经常会遇到需要在主线程中开启多个线程去并行执行任务,并且主线程需要等待所有子线程执行完毕后再进行汇总的场景.在 CountDownLatch 出现之前般都使用线程的join()方法来实现这一点,但是 join 方法不够灵活,不能够满足不同场景的需要,所以 JDK 开发组提供了 CountDownLatch 这个类,我们前面介绍的例子使用 CoumtDownLatch 会更优雅. 使用CountDownLatch 的代码如下: package LockSu

  • Java并发编程Semaphore计数信号量详解

    Semaphore 是一个计数信号量,它的本质是一个共享锁.信号量维护了一个信号量许可集.线程可以通过调用acquire()来获取信号量的许可:当信号量中有可用的许可时,线程能获取该许可:否则线程必须等待,直到有可用的许可为止. 线程可以通过release()来释放它所持有的信号量许可(用完信号量之后必须释放,不然其他线程可能会无法获取信号量). 简单示例: package me.socketthread; import java.util.concurrent.ExecutorService;

  • JAVA并发编程有界缓存的实现详解

    JAVA并发编程有界缓存的实现 1.有界缓存的基类 package cn.xf.cp.ch14; /** * *功能:有界缓存实现基类 *时间:下午2:20:00 *文件:BaseBoundedBuffer.java *@author Administrator * * @param <V> */ public class BaseBoundedBuffer<V> { private final V[] buf; private int tail; private int head

  • Java 并发编程:volatile的使用及其原理解析

    Java 并发编程:volatile的使用及其原理解析

    Java并发编程系列[未完]: •Java 并发编程:核心理论 •Java并发编程:Synchronized及其实现原理 •Java并发编程:Synchronized底层优化(轻量级锁.偏向锁) •Java 并发编程:线程间的协作(wait/notify/sleep/yield/join) •Java 并发编程:volatile的使用及其原理 一.volatile的作用 在<Java并发编程:核心理论>一文中,我们已经提到过可见性.有序性及原子性问题,通常情况下我们可以通过Synchroniz

随机推荐