超时机制的简单实现

最新推荐文章于 2024-01-03 13:58:20 发布
最新推荐文章于 2024-01-03 13:58:20 发布
阅读量1.5k 收藏 2
点赞数
文章标签： c/c++ java javascript ViewUI
原文链接：https://my.oschina.net/vincentzhao/blog/864548
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

在使用HttpClient过程中， 对于链接超时以及请求超时的设置是必不可少的。

HttpClient httpClient = new HttpClient();
httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(params.getConnectionTimeout());
httpClient.getHttpConnectionManager().getParams().setSoTimeout(params.getSoTimeout());

相对于客户端，服务端（譬如nginx）对于接收的多请求处理更为复杂。

请求数比较多的情况下，怎么判断每个请求的超时时间并加以处理？

  1. 将客户端的每个请求按照请求顺序依次放入有序集合（ArrayList）中，启动一个线程循环遍历该集合，如果发现有请求超时则中断该请求；
  2. 将客户端的每个请求依次放入排序集合（TreeMap）中，启动一个线程循环遍历每个元素，如果发现当前遍历的对象未超时，则停止后续遍历，已超时的则直接中断请求；
  3. 将客户端的每个请求按照超时时间存入排序阻塞集合(DelayQueue)中，启动线程获取集合数据时如果未到超时时间则阻塞线程。

分析以上三种方案：

  1. 每次需要循环遍历所有数据比对，如果说数据比较多的情况下耗时时间还是比较长的；如果数据比较少，并且超时时间未到，则cpu会消耗比较大(while(true))；
  2. 不用遍历所有数据，但会跟1存在cpu消耗比较大的情况；
  3. 借鉴了2的优势，同时又不会浪费cpu资源。

现在可以看下三种方案的简单实现：

第一种方案
package tech.zhaohuijun;

/**
 * Vincent 创建于 2017/03/22.
 */
public class Request {
    //服务器收到请求时间，单位毫秒
    private long receivetime;
    //超时时间，单位毫秒
    private long timeout;
    //请求状态 1请求中2请求完成3请求超时
    private int status=1;
    //请求名称
    private String name;

    public Request(String name) {
        this.name = name;
    }

    public void interrupt() {
        this.status = 3;
        System.out.println("请求"+this.getName()+"过期，已被中断");
    }

    public int getStatus() {
        return status;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public long getReceivetime() {
        return receivetime;
    }

    public void setReceivetime(long receivetime) {
        this.receivetime = receivetime;
    }

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }
}


package tech.zhaohuijun;

import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Vincent 创建于 2017/3/22.
 */
public class ServerTimeoutThread implements Runnable {

    private List<Request> requestList;

    private CountDownLatch countDownLatch;


    public ServerTimeoutThread(List<Request> requestList, CountDownLatch countDownLatch) {
        this.requestList = requestList;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        while (true) {
            for (Request request : requestList) {
                if (request.getReceivetime() + request.getTimeout() <= System.currentTimeMillis() && request.getStatus() == 1) {
                    request.interrupt();
                    countDownLatch.countDown();
                }
            }
            //为了测试cpu循环占用的问题，暂停500ms打印
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("------");
        }
    }
}


package tech.zhaohuijun;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * Vincent 创建于 2017/3/22.
 */
public class Server {

    private static final List<Request> REQUEST_LIST =new ArrayList<>();

    public static void main(String[] args) throws InterruptedException {
        //添加多个请求，超时时间不一样

        long currentTimeMillis = System.currentTimeMillis();

        //超时时间5s
        Request request1=new Request("request-1");
        request1.setReceivetime(currentTimeMillis);
        request1.setTimeout(5000);
        //超时时间15s
        Request request2=new Request("request-2");
        request2.setReceivetime(currentTimeMillis);
        request2.setTimeout(15000);
        //超时时间10s
        Request request3=new Request("request-3");
        request3.setReceivetime(currentTimeMillis);
        request3.setTimeout(10000);


        REQUEST_LIST.add(request1);
        REQUEST_LIST.add(request2);
        REQUEST_LIST.add(request3);

        CountDownLatch countDownLatch=new CountDownLatch(REQUEST_LIST.size());

        //启动线程处理超时
        Thread thread=new Thread(new ServerTimeoutThread(REQUEST_LIST,countDownLatch));
        thread.setDaemon(true);
        thread.start();

        countDownLatch.await();
    }

}

输出：

------
------
------
------
------
------
------
------
------
------
请求request-1过期，已被中断
------
------
------
------
------
------
------
------
------
------
请求request-3过期，已被中断
------
------
------
------
------
------
------
------
------
------
请求request-2过期，已被中断
第二种方案
package tech.zhaohuijun;

/**
 * Vincent 创建于 2017/03/22.
 */
public class Request {
    //服务器收到请求时间，单位毫秒
    private long receivetime;
    //超时时间，单位毫秒
    private long timeout;
    //请求状态 1请求中2请求完成3请求超时
    private int status=1;
    //请求名称
    private String name;

    public Request(String name) {
        this.name = name;
    }

    public void interrupt() {
        this.status = 3;
        System.out.println("请求"+this.getName()+"过期，已被中断");
    }

    public int getStatus() {
        return status;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public long getReceivetime() {
        return receivetime;
    }

    public void setReceivetime(long receivetime) {
        this.receivetime = receivetime;
    }

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }
}


package tech.zhaohuijun;

import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

/**
 * Vincent 创建于 2017/3/22.
 */
public class ServerTimeoutThread implements Runnable {

    private TreeMap<Long, Request> requestTreeMap;

    private CountDownLatch countDownLatch;


    public ServerTimeoutThread(TreeMap<Long, Request> requestTreeMap, CountDownLatch countDownLatch) {
        this.requestTreeMap = requestTreeMap;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        while (true) {
            Set<Map.Entry<Long, Request>> entrySet = requestTreeMap.entrySet();
            for (Map.Entry<Long, Request> entry : entrySet) {
                Request request = entry.getValue();
                if (entry.getKey() > System.currentTimeMillis()) {
                    break;
                }
                if (request.getStatus() == 1) {
                    request.interrupt();
                    countDownLatch.countDown();
                }
            }
            //为了测试cpu循环占用的问题，暂停500ms打印
            try {
                TimeUnit.MILLISECONDS.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("------");
        }
    }
}



package tech.zhaohuijun;

import java.util.TreeMap;
import java.util.concurrent.CountDownLatch;

/**
 * Vincent 创建于 2017/3/22.
 */
public class Server {

    private static final TreeMap<Long,Request> REQUEST_TREE_MAP =new TreeMap<>();

    public static void main(String[] args) throws InterruptedException {
        //添加多个请求，超时时间不一样

        long currentTimeMillis = System.currentTimeMillis();

        //超时时间5s
        Request request1=new Request("request-1");
        request1.setReceivetime(currentTimeMillis);
        request1.setTimeout(5000);
        //超时时间15s
        Request request2=new Request("request-2");
        request2.setReceivetime(currentTimeMillis);
        request2.setTimeout(15000);
        //超时时间10s
        Request request3=new Request("request-3");
        request3.setReceivetime(currentTimeMillis);
        request3.setTimeout(10000);


        REQUEST_TREE_MAP.put(request1.getReceivetime()+request1.getTimeout(),request1);
        REQUEST_TREE_MAP.put(request2.getReceivetime()+request2.getTimeout(),request2);
        REQUEST_TREE_MAP.put(request3.getReceivetime()+request3.getTimeout(),request3);

        CountDownLatch countDownLatch=new CountDownLatch(REQUEST_TREE_MAP.size());

        //启动线程处理超时
        Thread thread=new Thread(new ServerTimeoutThread(REQUEST_TREE_MAP,countDownLatch));
        thread.setDaemon(true);
        thread.start();

        countDownLatch.await();
    }

}

输出：


------
------
------
------
------
------
------
------
------
------
请求request-1过期，已被中断
------
------
------
------
------
------
------
------
------
------
请求request-3过期，已被中断
------
------
------
------
------
------
------
------
------
------
请求request-2过期，已被中断
第三种方案：
package tech.zhaohuijun;

import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

/**
 * Vincent 创建于 2017/03/22.
 */
public class Request implements Delayed {
    //服务器收到请求时间，单位毫秒
    private long receivetime;
    //超时时间，单位毫秒
    private long timeout;
    //请求状态 1请求中2请求完成3请求超时
    private int status=1;
    //请求名称
    private String name;

    public Request(String name) {
        this.name = name;
    }

    public void interrupt() {
        this.status = 3;
        System.out.println("请求"+this.getName()+"过期，已被中断");
    }

    public int getStatus() {
        return status;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    public long getReceivetime() {
        return receivetime;
    }

    public void setReceivetime(long receivetime) {
        this.receivetime = receivetime;
    }

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(this.getReceivetime()+this.getTimeout()-System.currentTimeMillis(),TimeUnit.MILLISECONDS);

    }

    @Override
    public int compareTo(Delayed o) {
        if(o == null || ! (o instanceof Request)) return 1;
        if(o == this) return 0;
        Request s = (Request)o;
        long l1 = this.getReceivetime() + this.getTimeout();
        long l2 = s.getReceivetime() + s.getTimeout();
        if (l1 > l2) {
            return 1;
        }else if (l1 == l2) {
            return 0;
        }else {
            return -1;
        }
    }
}


package tech.zhaohuijun;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.DelayQueue;

/**
 * Vincent 创建于 2017/3/22.
 */
public class ServerTimeoutThread implements Runnable {

    private DelayQueue<Request> requestDelayQueue;

    private CountDownLatch countDownLatch;


    public ServerTimeoutThread(DelayQueue<Request> requestDelayQueue, CountDownLatch countDownLatch) {
        this.requestDelayQueue = requestDelayQueue;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        while (true) {
            Request request = null;
            try {
                request = requestDelayQueue.take();
                if (request.getStatus() == 1) {
                    request.interrupt();
                    countDownLatch.countDown();
                }
                System.out.println("------");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }
    }
}


package tech.zhaohuijun;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.DelayQueue;

/**
 * Vincent 创建于 2017/3/22.
 */
public class Server {

    private static final DelayQueue<Request> REQUEST_DELAY_QUEUE =new DelayQueue<>();

    public static void main(String[] args) throws InterruptedException {
        //添加多个请求，超时时间不一样

        long currentTimeMillis = System.currentTimeMillis();

        //超时时间5s
        Request request1=new Request("request-1");
        request1.setReceivetime(currentTimeMillis);
        request1.setTimeout(5000);
        //超时时间15s
        Request request2=new Request("request-2");
        request2.setReceivetime(currentTimeMillis);
        request2.setTimeout(15000);
        //超时时间10s
        Request request3=new Request("request-3");
        request3.setReceivetime(currentTimeMillis);
        request3.setTimeout(10000);


        REQUEST_DELAY_QUEUE.put(request1);
        REQUEST_DELAY_QUEUE.put(request2);
        REQUEST_DELAY_QUEUE.put(request3);

        CountDownLatch countDownLatch=new CountDownLatch(REQUEST_DELAY_QUEUE.size());

        //启动线程处理超时
        Thread thread=new Thread(new ServerTimeoutThread(REQUEST_DELAY_QUEUE,countDownLatch));
        thread.setDaemon(true);
        thread.start();

        countDownLatch.await();
    }

}

输出:

请求request-1过期，已被中断
------
请求request-3过期，已被中断
------
请求request-2过期，已被中断
------

转载于:https://my.oschina.net/vincentzhao/blog/864548

csid_502
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
单个接口添加超时时间_一种极简的异步超时处理机制设计与实现（C#版）
weixin_39775872的博客
12-24 771
1.引言当执行某些动作之后，会期待反馈。最终要么是得到了结果，要么就是超时了。当超时发生时，可能是期望得到通知，或是希望能自动重试，等等。于是设计了一种通用的异步超时的处理机制，以期通过简洁易理解的方式完成超时的处理过程。2.对外接口设计从使用的角度，调用方期望的是“指定超时时长，时间到自动执行指定过程”，由此可以得出外部的操作接口参数。从功能角度来看，对于未超时的情况，需要提供在超时时长内随时清...
dubbo超时机制原理
小小少年的博客
09-16 2696
如果服务消费者调用超时，会抛出异常，来看下异常的原理：
c语言设计超时机制
最新发布
weixin_66634995的博客
01-03 1465
超时机制是一种控制程序执行时间的技术，用于避免程序无限期地等待某个操作完成。当程序执行某个操作时，如果超过了一定的时间限制还没有完成，超时机制将自动终止该操作并执行相应的处理。超时机制广泛应用于各种编程场景，例如多线程编程、网络编程和数据库操作等。本文介绍了在C语言中设计超时机制的方法以及其在多线程编程、网络编程和数据库操作等场景中的应用。通过使用超时机制，我们可以有效地控制程序的执行时间，避免程序长时间等待某个操作的完成。在实际应用中，根据具体场景选择合适的超时机制实现方式可以提高程序的可靠性和性能。
一种软件定时器/超时机制的实现方法
u014448875的博客
04-27 1665
实现方法概述简单方法优化方案计数值自减开启超时超时检测 概述 在程序设计中，常会遇到需要循环等待的问题，比如在while中等待串口中断接收完一帧数据。这时为了避免一直接收不到，程序进入死循环，我们会选择增加超时退出机制。 简单方法 这种实现方式相对比较简单，理解起来容易的多。比较适用于超时机制较少的程序。 首先需要三个变量，超时开始标志、超时计数值、超时时间到标志： volatile uint8_t g_xxx_Time_On_Flg=0; volatile uint16_t g_xxx_TimeCnt
串口编程-读写超时 COMMTIMEOUTS设置
weixin_33919941的博客
08-12 771
读写超时是在 调用 ReadFile 和 WriteFile 函数读写串口的时候系统提供的超时机制 typedef struct _COMMTIMEOUTS { DWORD ReadIntervalTimeout; /* Maximum time between read chars. */ DWORD ReadTotalTimeoutM...
超时/重发机制架构设计（单机版）
小浩子的博客
12-10 1954
在上一篇博文中提到用超时线程监控程序，那是对一整条业务的，如果要细分到每个子业务呢。这几天不断修修改改，总结出一套模型，直接上图，一目了然： 这里假设一个业务有3个子业务，这是针对单台物理机的，如果是多台机器，还需要在修改一部分内容，待我测试好再分享分布式的模型 ...
C++设置超时时间的简单实现方法
09-04
在C++编程中，有时我们需要控制网络通信中的超时机制，确保程序不会因等待无响应的连接或数据传输而陷入无限循环。一个常见的方法是利用操作系统提供的套接字API，尤其是`setsockopt`函数，来设定套接字的超时时间。...
Java实现心跳机制的方法
08-18
下面是一个基于Java实现的简单RPC框架实现心跳机制的示例代码： 心跳客户端类： ```java public class HeartbeatClient implements Runnable { private String serverIP = "127.0.0.1"; private int serverPort =...
JAVA WEB心跳机制简单实现代码
06-12
本篇文章将详细解析如何在Java Web中实现一个简单的心跳机制。 首先，我们需要理解心跳机制的基本原理。心跳机制就像两个人之间的对话，如果一段时间没有听到对方的声音，就会询问对方是否还在。在网络通信中，...
C# 实现Scoket心跳机制的方法
08-25
下面是一个简单的心跳实现的示例代码： ```csharp using System; using System.Collections.Generic; using System.Threading; namespace ConsoleApplication1 { // 客户端离线委托 public delegate void ...
超时：Crystal的超时实现
02-04
总结起来， Crystal 语言提供了多种方式来实现超时机制，包括使用 `Thread` 和 `sleep`、`Thread.raise` 以及第三方库如 `timeout`。根据具体需求和场景，可以选择最适合的方法来确保代码的健壮性和响应性。在实际...
Android超时机制
RamondLee的专栏
09-15 1万+
Android超时机制 作者 Liudroid 于2011 年 04 月 29 日 在Android 浏览:327℃ | 还没有评论，快来评论吧 由于手机端应用的响应，与当时的无线通信网络状况有很大的关联。而通信网络往往具有不稳定，延迟长的特点。所以，在我们的应用
c语言中的超时机制
热门推荐
xiaoliu198703的专栏
05-17 1万+
运行程序时，如果在一定时间内，程序中的一个功能还没有执行，此时，就要使用超时机制，跳出循环，报错或者终止程序执行。#include &lt;stdio.h&gt; #include &lt;sys/time.h&gt; void main() { float time_use=0; struct timeval start; struct timeval end;//struct tim...
Java任务超时处理机制实现
普普通通程序媛
02-18 7906
1.问题描述 在应用软件的开发中，经常会遇到这样的一种需求：需要实现一个方法来执行某种任务，而这个方法的执行时间不能超过指定值，如果超时，则调用者不管这个方法将来是否可能执行成功，都要中断它的执行，或者让这个方法返回。这就是超时处理问题。 根据执行任务的方法是否异步，可以把问题从两个方面分析：如果方法顺序执行，则方法执行时整个程序的控制权在执行任务的方法中，方法调用者对于任务的超时无能为力，只...
请求、响应与超时机制详解
qiuzhiqian1990的博客
03-16 9620
请求、响应与超时机制详解在C/S软件模型中，往往都遵循这请求和响应的机制，而且往往还伴随着超时控制。即：A发送请求，然后等待B的响应，同时开始超时计时，如果在超时时间内成功接收到响应，则结束等待和计时。如果到了超时时间还没有接收到响应，则结束等待同时此次通讯失败。我们站在A端来设计。 A发送通讯请求，然后进入等待状态。此时常见的操作就是将当前线程挂起(suspend)。让挂起线程进入就绪状态有两个
java利用Condition做超时机制
kc58236582的博客
09-11 3668
利用Condition做超时机制，主要是碰到阻塞的代码。我们希望做一个超时。当一直阻塞的时候，主线程也可以继续往下走。而当没有阻塞时，可以直接往下继续走。 我们知道Lock和Condition功能，可以做线程同步用。这里我们做一个超时机制，主要是碰到会阻塞的情况。这时候我们就新建一个线程，然后在主线程中利用Condition的await函数。而在新建的线程中，有一点要特别注意就是这个Lo
超时与重试机制(1)—《亿级流量》
java、c++、机器学习方向King
06-22 2234
https://mp.weixin.qq.com/s/-8dyHi7BVIfKlNWxUUskwg?utm_source=tuicool&utm_medium=referral 在实际开发过程中，笔者见过太多故障是因为超时没有设置或者设置的不对而造成的。而这些故障都是因为没有意识到超时设置的重要性而造成的。如果应用不设置超时，则可能会导致请求响应慢，慢请求累积导致连锁反应，甚至应用雪崩。
java 超时状态_Java任务超时处理机制实现【原创】
05-25
为了避免这种情况的发生，我们需要实现一个Java任务超时处理机制。 下面我将介绍一种比较简单的实现方式，希望对大家有所帮助。 1. 创建一个FutureTask对象 首先，我们需要创建一个FutureTask对象来封装我们的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值