多线程异步调用 多线程异步调用等待响应结果后继续处理 千次阅读

2017-02-07 19:14:04

1、在有响应的时候，使用ResponseFuture对象，并在onResponse方法中，将响应设置到Futrue中。

import com.google.common.util.concurrent.AbstractFuture;

public class ResponseFuture<JsonProtocol> extends AbstractFuture<JsonProtocol>

{

private final Executor executor;

public ResponseFuture()

{

if (ThreadLocalUtil.get("isServer") == null)

{

//TODO 这里是错误的，把这行代码移到一个单例的全局共享中取，避免每次new。如果是服务端，那么所有的服务端都共享一个线程池

executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(),

new RpcThreadFacotry("CallBack"));

}

else

{

//单线程执行器

executor = MoreExecutors.directExecutor();

}

}

/**

   * 当响应回来的时候，结果被设置到future中，因此从future中可以获得一个异步的响应结果

   * @param responseProtocol

   */

public void onResponse(JsonProtocol responseProtocol)

{

//向future中设置值

super.set(responseProtocol);

}

/**

   * 当响应有结果时候可以直接runnable的方法

   * @param runnable

   */

public void addCallBack(Runnable runnable)

{

super.addListener(runnable, executor);

}

}

2、等待线程获得响应结果（使用future.get阻塞等待异步线程的响应）

ResponseFuture<JsonProtocol> reponseFuture = client.futureInvoke(JsonProtocolReqeust);

JsonProtocol JsonProtocolResponse = null;

try

{

JsonProtocolResponse = reponseFuture.get(JsonProtocolReqeust.getRpcMetadata().getTimeOut(),

TimeUnit.MILLISECONDS);

}

catch (ExecutionException e){}

catch (TimeoutException e)

{

throw new RuntimeException("调用远程服务响应超时", e);

}

更多相关内容
多线程异步调用（并参递参数）
2012-01-12 10:02:59

多线程异步调用（并参递参数）经典代码示例

收起

Python多线程异步调用

2021-01-28 16:09:29

本博客主要实现一个python多线程异步调用的demo。程序功能简介：调用main_func作为主程序，主程序内部创建两个线程，分别建立线程ID、线程名和线程内部执行延迟时间，两个线程内部分别调用函数print_time...

本博客主要实现一个python多线程异步调用的demo。
程序功能简介：调用main_func作为主程序，主程序内部创建两个线程，分别建立线程ID、线程名和线程内部执行延迟时间，两个线程内部分别调用函数print_time打印时间。exitFlag作为标志位，如果为1表示线程不打印时间直接退出。
结果分析：程序主线程已经执行结束，并不影响其建立的线程执行，所以可以实现异步调用。

程序代码：

import threading
import time

exitFlag = 0

class myThread (threading.Thread):
    def __init__(self, threadID, name, delay):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = delay
    def run(self):
        print ("开始线程：" + self.name)
        print_time(self.name, self.delay, 3)
        print ("退出线程：" + self.name)

def print_time(threadName, delay, times):
    for i in range(times):
        if exitFlag:
            threadName.exit()
        time.sleep(delay)
        print ("%s: %s" % (threadName, time.ctime(time.time())))

def main_func():
    # 创建新线程
    thread1 = myThread(1, "Thread-1", 1)
    thread2 = myThread(2, "Thread-2", 2)
    # 开启新线程
    thread1.start()
    thread2.start()
    return '主程序执行结束！'
if __name__ == "__main__":
    result = main_func()
    print(result)

执行结果

在这里插入图片描述

收起

展开全文

Java多线程实现异步调用的方法
2020-09-03 07:27:34

本文给大家分享java多线程实现异步调用的方法，感兴趣的朋友跟着脚本之家小编一起学习吧

收起
Labview2015多线程异步调用工程
2016-09-27 21:41:51

labview2015关于异步调用功能的研究工程，主要用于解决主线程负责快速轮询，多个子线程负责具体的任务处理并反馈给主线程（子线程需要长时间处理任务），解决单纯的可重复VI不能实现并行的功能。

收起
Labview异步调用示例
2019-03-31 20:58:53

异步调用示例,Labview异步调用示例

收起

【Java多线程】多线程实现异步调用结果返回

千次阅读 2020-05-18 20:01:15

因此可以使用异步调用的方法，不阻塞当前其他任务的执行。小栗子首先我们先要创建一个线程池，可以根据自己的需求创建，什么IO密集型参数设置，CPU密集型参数的设置。这里我们仅仅想让10个任务一起跑。 ...

前言

在我们的业务中很可能会碰到需要执行一段时间的任务，并且如果同步的话就会造成一些无谓的等待。因此可以使用异步调用的方法，不阻塞当前其他任务的执行。

小栗子

首先我们先要创建一个线程池，可以根据自己的需求创建，什么IO密集型参数设置，CPU密集型参数的设置。这里我们仅仅想让10个任务一起跑。

ExecutorService threadPool = new ThreadPoolExecutor(
                        10,
                        10,
                        0,
                        TimeUnit.SECONDS,
                        new SynchronousQueue<>(),
                        new ThreadPoolExecutor.AbortPolicy());

然后模拟下需要异步调用的业务的执行,这里我的n给不同线程设置了不同的执行时间，在判断超时时，会有部分线程无法完成任务。

AtomicInteger atomicInteger = new AtomicInteger(5);
List<Future<Integer>> futures = new ArrayList<>(); //存储结果
for (int i = 0; i < 10; i++) {
            Future<Integer> submit = completionService.submit(() -> {
                int n = atomicInteger.getAndIncrement();
                int h = 0;
                for (int j = n * 10; j < n * 10 + n; j++) {
                    h += j;
                    TimeUnit.SECONDS.sleep(1); //暂停线程1s
                }
                return h;

            });
            futures.add(submit);
        }

现在执行下其他的业务操作。

然后设置一些调用其他接口超时的时间，避免过长等待并开始获取下调用的结果。

		Set<AjaxResult> flags = new HashSet<>();
        List<AjaxResult> FAILS =new LinkedList<>();
        long startTime = System.currentTimeMillis();
        long timeout = 1000 * 10;
         while (flags.size()+FAILS.size()<futures.size()) {
            for (Future<Integer> o : futures) {
                if (System.currentTimeMillis() - startTime > timeout ){// 如果超时采取一定措施，或者返回一个失败。
                    FAILS.add(new AjaxResult("fail",0));
                    if(flags.size()+FAILS.size()>=futures.size()){
                        break;
                    }
                    continue;
                }
                if (o.isDone()) {
                    flags.add(new AjaxResult("success", o.get()));
                }
            }

         }
        long endTime = System.currentTimeMillis();

这里将结果分失败和成功进行存储。并记录处理的时间

接下来看下最后输出结果

		System.out.println("执行结束");
        System.out.println("耗时" + (endTime - startTime));
        System.out.println("结果" + flags.toString());
        System.out.println("失败" + FAILS.toString());
        System.exit(0);

在这里插入图片描述
本方法纯属瞎玩，仅供参考。

下面是全部的代码

public class InitConfig {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ExecutorService threadPool = new ThreadPoolExecutor(
                        10,
                        10,
                        0,
                        TimeUnit.SECONDS,
                        new SynchronousQueue<>(),
                        new ThreadPoolExecutor.AbortPolicy());
        CompletionService<Integer> completionService = new ExecutorCompletionService<>(threadPool);
        AtomicInteger atomicInteger = new AtomicInteger(5);
        List<Future<Integer>> futures = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Future<Integer> submit = completionService.submit(() -> {
                int n = atomicInteger.getAndIncrement();
                int h = 0;
                for (int j = n * 10; j < n * 10 + n; j++) {
                    h += j;
                    TimeUnit.SECONDS.sleep(1); //暂停线程1s
                }
                return h;

            });
            futures.add(submit);
        }
        Set<AjaxResult> flags = new HashSet<>();
        List<AjaxResult> FAILS =new LinkedList<>();
        long startTime = System.currentTimeMillis();
        long timeout = 1000 * 10;
         while (flags.size()+FAILS.size()<futures.size()) {
            for (Future<Integer> o : futures) {
                if (System.currentTimeMillis() - startTime > timeout ){
                    FAILS.add(new AjaxResult("fail",0));
                    if(flags.size()+FAILS.size()>=futures.size()){
                        break;
                    }
                    continue;
                }
                if (o.isDone()) {
                    flags.add(new AjaxResult("success", o.get()));
                }
            }

         }
        long endTime = System.currentTimeMillis();
        System.out.println("执行结束");
        System.out.println("耗时" + (endTime - startTime));
        System.out.println("结果" + flags.toString());
        System.out.println("失败" + FAILS.toString());
        System.exit(0);
    }

    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    @ToString
    @EqualsAndHashCode
    static class AjaxResult {
        private String ret;
        private Integer data;
    }


}

收起

展开全文

java 并发编程

Java创建多线程异步执行实现代码解析
2020-08-18 17:48:08

主要介绍了Java创建多线程异步执行实现代码解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

收起