精华内容
下载资源
问答
  • java 设置超时

    2015-01-05 09:50:56
    就不连接DB了, 研究了好久,DataSource里面的setLoginTimeOut 根本没法用, 刚开始一直纠结在大google搜索"java get connection 超时"答案上, 但始终找不到答案, 偶然尝试了下"java 设置超时" 问题就迎刃而解了. ...
    最近有个需求, 当DB压力过大时获取Connction的时间过慢长时间不返回的话, 就不连接DB了, 研究了好久,DataSource里面的setLoginTimeOut 根本没法用, 刚开始一直纠结在大google搜索"java get connection 超时"答案上, 但始终找不到答案, 偶然尝试了下"java 设置超时" 问题就迎刃而解了.

    java早已经给我们提供了解决方案。jdk1.5自带的并发库中Future类就能满足这个需求。Future类中重要方法包括get()和cancel()。get()获取数据对象,如果数据没有加载,就会阻塞直到取到数据,而 cancel()是取消数据加载。另外一个get(timeout)操作,表示如果在timeout时间内没有取到就失败返回,而不再阻塞。
    看来不能一直纠结在一条道上, 偶尔换个思路还是很有帮助的,  不多说了, 解决方案如下

    我的code:
    Java代码  收藏代码
    1. public boolean checkDBStatus() {  
    2.     boolean bdStatus = false;  
    3.   
    4.     final ExecutorService exec = Executors.newFixedThreadPool(1);  
    5.     Callable<String> call = new Callable<String>() {  
    6.         public String call() throws Exception {  
    7.             DataSource dataSource = getJdbcTemplate().getDataSource();  
    8.             Connection connection = dataSource.getConnection();  
    9.             Statement statement = connection.createStatement();  
    10.             statement.executeQuery("select * from citirisk_menu_node");  
    11.             return "true";  
    12.         }  
    13.     };  
    14.   
    15.     try {  
    16.         Future<String> future = exec.submit(call);  
    17.         // set db connection timeout to 10 seconds  
    18.         String obj = future.get(1000 * 10, TimeUnit.MILLISECONDS);   
    19.         bdStatus = Boolean.parseBoolean(obj);  
    20.         System.out.println("the return value from call is :" + obj);  
    21.     } catch (TimeoutException ex) {  
    22.         System.out.println("====================task time out===============");  
    23.         ex.printStackTrace();  
    24.         bdStatus = false;  
    25.     } catch (Exception e) {  
    26.         System.out.println("failed to handle.");  
    27.         e.printStackTrace();  
    28.         bdStatus = false;  
    29.     }  
    30.     // close thread pool  
    31.     exec.shutdown();  
    32.   
    33.     return bdStatus;  
    34. }  


    在Java中,如果需要设定代码执行的最长时间,即超时,可以用Java线程池ExecutorService类配合Future接口来实现。 Future接口是Java标准API的一部分,在java.util.concurrent包中。Future接口是Java线程Future模式的实现,可以来进行异步计算。

    Future模式可以这样来描述:我有一个任务,提交给了Future,Future替我完成这个任务。期间我自己可以去做任何想做的事情。一段时间之后,我就便可以从Future那儿取出结果。就相当于下了一张订货单,一段时间后可以拿着提订单来提货,这期间可以干别的任何事情。其中Future 接口就是订货单,真正处理订单的是Executor类,它根据Future接口的要求来生产产品。

    Future接口提供方法来检测任务是否被执行完,等待任务执行完获得结果,也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程序执行超时的关键。

    Future接口是一个泛型接口,严格的格式应该是Future<V>,其中V代表了Future执行的任务返回值的类型。 Future接口的方法介绍如下:

        boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行,或者等等任务结束
        boolean isCancelled () 任务是否已经取消,任务正常完成前将其取消,则返回 true
        boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消,都将返回true
        V get () throws InterruptedException, ExecutionException  等待任务执行结束,然后获得V类型的结果。InterruptedException 线程被中断异常, ExecutionException任务执行异常,如果任务被取消,还会抛出CancellationException
        V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样,多了设置超时时间。参数timeout指定超时时间,uint指定时间的单位,在枚举类TimeUnit中有相关的定义。如果计算超时,将抛出TimeoutException

    Future的实现类有java.util.concurrent.FutureTask<V>即 javax.swing.SwingWorker<T,V>。通常使用FutureTask来处理我们的任务。FutureTask类同时又实现了Runnable接口,所以可以直接提交给Executor执行。使用FutureTask实现超时执行的代码如下:

    Java代码  收藏代码
    1. ExecutorService executor = Executors.newSingleThreadExecutor();    
    2. FutureTask<String> future =    
    3.        new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数    
    4.          public String call() {    
    5.            //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型    
    6.        }});    
    7. executor.execute(future);    
    8. //在这里可以做别的任何事情    
    9. try {    
    10.     result = future.get(5000, TimeUnit.MILLISECONDS); //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果    
    11. catch (InterruptedException e) {    
    12.     futureTask.cancel(true);    
    13. catch (ExecutionException e) {    
    14.     futureTask.cancel(true);    
    15. catch (TimeoutException e) {    
    16.     futureTask.cancel(true);    
    17. finally {    
    18.     executor.shutdown();    
    19. }    



    不直接构造Future对象,也可以使用ExecutorService.submit方法来获得Future对象,submit方法即支持以 Callable接口类型,也支持Runnable接口作为参数,具有很大的灵活性。使用示例如下:
    Java代码  收藏代码
    1. ExecutorService executor = Executors.newSingleThreadExecutor();    
    2. FutureTask<String> future = executor.submit(    
    3.    new Callable<String>() {//使用Callable接口作为构造参数    
    4.        public String call() {    
    5.       //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型    
    6.    }});    
    7. //在这里可以做别的任何事情    
    8. //同上面取得结果的代码  
    展开全文
  • public class WxToken { private... // 第三步:设置超时时间(保存100分钟) token.expiryTime = System.currentTimeMillis() + 1000 * 60 * 100L; } // 调用 public String getAccessToken() { return accessToken; } }

    public class WxToken {

    private String accessToken; //token信息

    private Long expiryTime; // 过期时间

    private static WxToken token = new WxToken();

    private WxToken() {}

    public static synchronized WxToken getInstance() {

    if(null == token.expiryTime) {

    init();

    }else {

    // 确保当前时间一定要小于过期时间

    if(System.currentTimeMillis() >= token.expiryTime) {

    init();

    }

    }

    return token;

    }

    /**

    * 初始化方法

    */

    private static void init() {

    // 第一步:获取token(根据业务补充)

    // 第二步:保存

    // token.accessToken = json.getString("access_token");

    // 第三步:设置超时时间(保存100分钟)

    token.expiryTime = System.currentTimeMillis() + 1000 * 60 * 100L;

    }

    // 调用

    public String getAccessToken() {

    return accessToken;

    }

    }

    展开全文
  • 对于java中线程超时间可以使用ExecutorService与Timer来控制一个线程什么时候超时了,下面我整理了一些方法,这些文章都详细的介绍java线程超时设置技巧。方法一本例子使用ExecutorService 替代Timer来控制一个线程...

    对于java中线程超时间可以使用ExecutorService与Timer来控制一个线程什么时候超时了,下面我整理了一些方法,这些文章都详细的介绍java线程超时设置技巧。

    方法一

    本例子使用ExecutorService 替代Timer来控制一个线程的超时。代码如下:

     代码如下 复制代码

    package com.stackoverflow.q2275443;

    import java.util.concurrent.Callable;

    import java.util.concurrent.ExecutorService;

    import java.util.concurrent.Executors;

    import java.util.concurrent.Future;

    import java.util.concurrent.TimeUnit;

    import java.util.concurrent.TimeoutException;

    public class Test {

    public static void main(String[] args) throws Exception {

    ExecutorService executor = Executors.newSingleThreadExecutor();

    Future future = executor.submit(new Task());

    try {

    System.out.println("Started..");

    System.out.println(future.get(3, TimeUnit.SECONDS));

    System.out.println("Finished!");

    } catch (TimeoutException e) {

    System.out.println("Terminated!");

    }

    executor.shutdownNow();

    }

    }

    class Task implements Callable {

    @Override

    public String call() throws Exception {

    Thread.sleep(4000); //  www.jquerycn.cn Just to demo a long running task of 4 seconds.

    return "Ready!";

    }

    }

    将上面的

    System.out.println(future.get(3, TimeUnit.SECONDS));

    改为

    System.out.println(future.get(5, TimeUnit.SECONDS));

    线程将能正确执行完

    You can intercept the timeout in the catch (TimeoutException e) block.

    方法二

    类1:守护线程类

     代码如下 复制代码

    /**

    * 本线程设置了一个超时时间

    * 该线程开始运行后,经过指定超时时间,

    * 该线程会抛出一个未检查异常通知调用该线程的程序超时

    * 在超时结束前可以调用该类的cancel方法取消计时

    * @author solonote

    */

    public class TimeoutThread extends Thread{

    /**

    * 计时器超时时间

    */

    private long timeout;

    /**

    * 计时是否被取消

    */

    private boolean isCanceled = false;

    /**

    * 当计时器超时时抛出的异常

    */

    private TimeoutException timeoutException;

    /**

    * 构造器

    * @param timeout 指定超时的时间

    */

    public TimeoutThread(long timeout,TimeoutException timeoutErr) {

    super();

    this.timeout = timeout;

    this.timeoutException = timeoutErr;

    //设置本线程为守护线程

    this.setDaemon(true);

    }

    /**

    * 取消计时

    */

    public synchronized void cancel()

    {

    isCanceled = true;

    }

    /**

    * 启动超时计时器

    */

    public void run()

    {

    try {

    Thread.sleep(timeout);

    if(!isCanceled)

    throw timeoutException;

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    注: 类一中的TimeoutException是下边的用户自定义类,不是java中的java.util.concurrent.TimeoutException

    类2.抛出异常类,该类继承了RuntimeException,原因是run方法不能抛出已检测异常。

    public class TimeoutException extends RuntimeException {

    /**

    * 序列化号

    */

    private static final long serialVersionUID = -8078853655388692688L;

    public TimeoutException(String errMessage)

    {

    super(errMessage);

    }

    }

    使用方法:

    //初始化超时类

    TimeoutThread t = new TimeoutThread(5000,new TimeoutException("超时"));

    try{

    t.start();

    .....要检测超时的程序段....

    t.cancel();

    }catch (TimeoutException e)

    {

    ...对超时的处理...

    }

    TimeoutException可以更换为其他未检查异常类。

    方法说明:

    本方法的使用可以实现线程自己管理超时,并且可以管理某一段代码超时时,可以在方法内部给出处理办法。

    但是需要注意的是:本方法的超时时间并不是当前线程的运行时间,而是计时器开始计时起系统运行的时间。

    展开全文
  • Socket Java设置超时时间

    千次阅读 2017-07-12 16:53:59
    Socket Java设置超时时间 Socket Client Example // File Name GreetingClient.java import java.net.*; import java.io.*; public class GreetingClient { public static void main(String [] args) { Strin

    Socket Java设置超时时间

    Socket Client Example

    // File Name GreetingClient.java
    import java.net.*;
    import java.io.*;
    
    public class GreetingClient {
    
       public static void main(String [] args) {
          String serverName = args[0];
          int port = Integer.parseInt(args[1]);
          try {
             System.out.println("Connecting to " + serverName + " on port " + port);
             Socket client = new Socket(serverName, port);
    
             System.out.println("Just connected to " + client.getRemoteSocketAddress());
             OutputStream outToServer = client.getOutputStream();
             DataOutputStream out = new DataOutputStream(outToServer);
    
             out.writeUTF("Hello from " + client.getLocalSocketAddress());
             InputStream inFromServer = client.getInputStream();
             DataInputStream in = new DataInputStream(inFromServer);
    
             System.out.println("Server says " + in.readUTF());
             client.close();
          }catch(IOException e) {
             e.printStackTrace();
          }
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    Socket Server Example
    连接端口自定义,通过arg设置

    // File Name GreetingServer.java
    import java.net.*;
    import java.io.*;
    
    public class GreetingServer extends Thread {
       private ServerSocket serverSocket;
    
       public GreetingServer(int port) throws IOException {
          serverSocket = new ServerSocket(port);
          serverSocket.setSoTimeout(10000);
       }
    
       public void run() {
          while(true) {
             try {
                System.out.println("Waiting for client on port " + 
                   serverSocket.getLocalPort() + "...");
                Socket server = serverSocket.accept();
    
                System.out.println("Just connected to " + server.getRemoteSocketAddress());
                DataInputStream in = new DataInputStream(server.getInputStream());
    
                System.out.println(in.readUTF());
                DataOutputStream out = new DataOutputStream(server.getOutputStream());
                out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress()
                   + "\nGoodbye!");
                server.close();
    
             }catch(SocketTimeoutException s) {
                System.out.println("Socket timed out!");
                break;
             }catch(IOException e) {
                e.printStackTrace();
                break;
             }
          }
       }
    
       public static void main(String [] args) {
          int port = Integer.parseInt(args[0]);
          try {
             Thread t = new GreetingServer(port);
             t.start();
          }catch(IOException e) {
             e.printStackTrace();
          }
       }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    设置超时
    1.设置连接请求超时时间,如果连接无响应,则抛出超时异常
    2.设置读操作超时时长,如过读取数据流时间超时,则抛出异常

    Socket socket = new Socket();
    socket.connect(new InetSocketAddress(ipAddress, port), 1000);//设置连接请求超时时间10 s
    socket.setSoTimeout(30000);//设置读操作超时时间30 s
    • 1
    • 2
    • 3
    • 1
    • 2
    • 3

    注意:socket.setSoTimeout必须在connect之后设置,不然将不会生效。读操作将永远不会超时。


    参考:
    https://www.tutorialspoint.com/java/java_networking.htm
    http://stackoverflow.com/questions/4969760/set-timeout-for-socket
    http://docs.oracle.com/javase/7/docs/api/java/net/Socket.html

    展开全文
  • 任务超时处理是比较常见的需求,比如在进行一些比较耗时的操作(如网络请求)或者在占用一些比较宝贵的资源(如数据库连接)时,我们通常需要给这些操作设置一个超时时间,当执行时长超过设置的阈值的时候,就终止操作并...
  • java了一个java方法,它连接到web服务。我想举例来说,它需要超过5秒,然后停止当前的程序和重新启动3次以上。如果所有时间都失败,则完全中止。到目前为止,我写了以下内容:private ConnectionInterface ...
  • 连接超时时间的话有很多办法,最常用的是 在你的oracle服务器的 $ORACLE_HOME/network/admin 中的 sqlnet.ora中设置参数SQLNET.EXPIRE_TIME= n n为一个指定的分钟数 当客户端中断,在 n 分钟内就可以自动断开连接。...
  • 我们写一个有超时功能的 Callable:import java.util.concurrent.*;public class TimeoutCallable implements Callable {private final Callable callable;private final V timeoutV;private final long timeout;/**...
  • java设置超时限制

    千次阅读 2018-01-29 16:16:44
     //limi是设置的时间限制 单位:毫秒  state = future.get(limi, TimeUnit.MILLISECONDS);   } catch (InterruptedException e) {   // 中断线程  e.printStackTrace();   } catch ...
  • 我正在尝试为我正在处理的行设置一个Lock,直到下一次提交:entityManager.createQuery("SELECT value from Table where id=:id").setParameter("id","123").setLockMode(LockModeType.PESSIMISTIC_WRITE).setHint(...
  • 我有一个处理长时间运行的HTTP请求的Jetty...进程X在请求的超时时间结束 – 否问题>进程X从不完成 – 发生异常如何检测这种情况(3)并防止异常,同时允许其他两种情况正常工作?例外:2012-06-18 00:13:31.055:WARN...
  • /*** 本线程设置了一个超时时间* 该线程开始运行后,经过指定超时时间,* 该线程会抛出一个未检查异常通知调用该线程的程序超时* 在超时结束前可以调用该类的cancel方法取消计时* @author solonote*/public class ...
  • //上面两种方式都是通过控制底层的http连接来达到timeout控制,如果超时会抛出 java.net.SocketTimeoutException: Read timed out. //3,jax-ws的客户端:同样利用CXF的ClientProxy控制http连接: URL wsdlURL = new ...
  • java如何设置超时时间[2021-02-01 12:11:14]简介:PHP请求远程地址设置超时时间的方法:1、【file_get_contents】请求超时设置;2、fopen请求超时设置;3、curl请求超时设置。【相关学习推荐:php编程(视频)】PHP请求...
  • 网上看了写文章,发现很多设置socket超时时间使用的是:setSoTimeout这个方法,但这个不是设置超时方法,具体的作用自己google一下。socket有一个connect的方法,里面的最后一个参数就是超时的参数:/*** Connects ...
  • java设置http请求超时时间 Java 设置Http 请求超时时间 Java中可以使用HttpURLConnection来请求WEB资源。 HttpURLConnection对象不能直接构造,需要通过URL.openConnection来获 得HttpURLConnection对象,示例代码...
  • //上面两种方式都是通过控制底层的http连接来达到timeout控制,如果超时会抛出 java.net.SocketTimeoutException: Read timed out. //3,jax-ws的客户端:同样利用CXF的ClientProxy控制http连接: URL wsdlURL = new ...
  • java中对Socket设置超时时间主要有以下两种方式,我们来看一下:(推荐:java视频教程)方式1:Socket s=new Socket();s.connect(new InetSocketAddress(host,port),10000);方式2:Socket s=new Socket("127.0.0.1",...
  • [http是无状态的连接,不像socket可以有timeout的异常,因此在判断...声明一个booleaHTTP请求时设置超时时间是明智的,避免死等。HttpPost request = new HttpPost(requestUrl);HttpClient client = new DefaultHtt...
  • 如果HTTP连接没有超时,你可以在后台线程本身(AsyncTask,Service等)中实现超时检查器,下面的类是Customize AsyncTask的一个例子,它在一段时间后超时public abstract class AsyncTaskWithTimer extendsAsyncTask {...
  • 在web容器中设置(以tomcat为例)在tomcat-7.0\conf\web.xml中设置,以下是tomcat7.0中默认配置:30tomcat默认session超时时间为30分钟,可以根据需要修改,负数或0为不限制session失效时间这里要...
  • 我正在尝试使用Java设置网络超时我的Oracle数据库连接.但是,我收到了一个错误.下面是示例代码,它是相应的例外.try{conn = new Database("oracle").connect();conn.setNetworkTimeout(null, 30000); //I don't have ...
  • Java中可以使用HttpURLConnection来请求WEB资源。HttpURLConnection对象不能直接构造,需要通过URL.openConnection()来获得HttpURLConnection对象,示例代码如下:String szUrl = "http://www.zhixing123.cn/";URL ...
  • SpringBoot设置接口访问超时时间有两种方式一、在配置文件application.properties中加了spring.mvc.async.request-timeout=20000,意思是设置超时时间为20000ms即20s,二、还有一种就是在config配置类中加入:public...
  • java 方法的执行时间监控 设置超时(Future 接口)import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent...
  • 主要有以下两种方式,我们来看一下方式1:Socket s=newSocket(); s.connect(new InetSocketAddress(host,port),10000);...那么这两种方式设置超时时间各自代表了什么意义呢?有什么区别呢?第1种方式我们先来看一...
  • 慕斯王如果HTTP连接没有超时,则可以在后台线程本身(AsyncTask,Service等)中实现超时检查器,以下类是Customize AsyncTask的示例,该示例在特定时间段后超时public abstract class AsyncTaskWithTimer extends ...
  • 如果当时客户端没有设置超时时间的话,会在客户端中产生级联故障。先用一张图来说明一下。聚合层除了调用购物车微服务,还调用了营销系统微服务。如果购物车服务的接口响应时间很慢,而客户端聚合层调用购物车服务时...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,151
精华内容 860
关键字:

java设置超时

java 订阅