-
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:- public boolean checkDBStatus() {
- boolean bdStatus = false;
- final ExecutorService exec = Executors.newFixedThreadPool(1);
- Callable<String> call = new Callable<String>() {
- public String call() throws Exception {
- DataSource dataSource = getJdbcTemplate().getDataSource();
- Connection connection = dataSource.getConnection();
- Statement statement = connection.createStatement();
- statement.executeQuery("select * from citirisk_menu_node");
- return "true";
- }
- };
- try {
- Future<String> future = exec.submit(call);
- // set db connection timeout to 10 seconds
- String obj = future.get(1000 * 10, TimeUnit.MILLISECONDS);
- bdStatus = Boolean.parseBoolean(obj);
- System.out.println("the return value from call is :" + obj);
- } catch (TimeoutException ex) {
- System.out.println("====================task time out===============");
- ex.printStackTrace();
- bdStatus = false;
- } catch (Exception e) {
- System.out.println("failed to handle.");
- e.printStackTrace();
- bdStatus = false;
- }
- // close thread pool
- exec.shutdown();
- return bdStatus;
- }
在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实现超时执行的代码如下:- ExecutorService executor = Executors.newSingleThreadExecutor();
- FutureTask<String> future =
- new FutureTask<String>(new Callable<String>() {//使用Callable接口作为构造参数
- public String call() {
- //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型
- }});
- executor.execute(future);
- //在这里可以做别的任何事情
- try {
- result = future.get(5000, TimeUnit.MILLISECONDS); //取得结果,同时设置超时执行时间为5秒。同样可以用future.get(),不设置执行超时时间取得结果
- } catch (InterruptedException e) {
- futureTask.cancel(true);
- } catch (ExecutionException e) {
- futureTask.cancel(true);
- } catch (TimeoutException e) {
- futureTask.cancel(true);
- } finally {
- executor.shutdown();
- }
不直接构造Future对象,也可以使用ExecutorService.submit方法来获得Future对象,submit方法即支持以 Callable接口类型,也支持Runnable接口作为参数,具有很大的灵活性。使用示例如下:
- ExecutorService executor = Executors.newSingleThreadExecutor();
- FutureTask<String> future = executor.submit(
- new Callable<String>() {//使用Callable接口作为构造参数
- public String call() {
- //真正的任务在这里执行,这里的返回值类型为String,可以为任意类型
- }});
- //在这里可以做别的任何事情
- //同上面取得结果的代码
-
java 设置 超时_Java设置超时保存对象
2021-03-07 09:52:56public 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 设置超时_java线程超时设置方法
2021-02-12 13:06:36对于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:59Socket Java设置超时时间 Socket Client Example // File Name GreetingClient.java import java.net.*; import java.io.*; public class GreetingClient { public static void main(String [] args) { StrinSocket 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如何实现任务超时处理
2021-02-12 13:06:36任务超时处理是比较常见的需求,比如在进行一些比较耗时的操作(如网络请求)或者在占用一些比较宝贵的资源(如数据库连接)时,我们通常需要给这些操作设置一个超时时间,当执行时长超过设置的阈值的时候,就终止操作并... -
java 设置超时_如何在Java方法中设置超时,并定期重试该方法
2021-02-12 13:06:31我java了一个java方法,它连接到web服务。我想举例来说,它需要超过5秒,然后停止当前的程序和重新启动3次以上。如果所有时间都失败,则完全中止。到目前为止,我写了以下内容:private ConnectionInterface ... -
java 设置 超时_Java:这两种设置超时时间有什么不同?
2021-03-05 20:45:51连接超时时间的话有很多办法,最常用的是 在你的oracle服务器的 $ORACLE_HOME/network/admin 中的 sqlnet.ora中设置参数SQLNET.EXPIRE_TIME= n n为一个指定的分钟数 当客户端中断,在 n 分钟内就可以自动断开连接。... -
java设置超时_Java:如何实现代码超时功能?
2021-02-12 12:46:35我们写一个有超时功能的 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 ... -
Java设置超时锁_java – 如何在postgres中设置锁定超时 – Hibernate
2021-03-15 13:15:11我正在尝试为我正在处理的行设置一个Lock,直到下一次提交:entityManager.createQuery("SELECT value from Table where id=:id").setParameter("id","123").setLockMode(LockModeType.PESSIMISTIC_WRITE).setHint(... -
java设置超时终止方法,java – 如何处理Jetty异常 – 长时间运行的HTTP请求超时,但它所调用的进程永远不会...
2021-03-23 21:39:42我有一个处理长时间运行的HTTP请求的Jetty...进程X在请求的超时时间结束 – 否问题>进程X从不完成 – 发生异常如何检测这种情况(3)并防止异常,同时允许其他两种情况正常工作?例外:2012-06-18 00:13:31.055:WARN... -
java 线程设置超时时间_java线程超时设置方法
2021-02-12 22:23:34/*** 本线程设置了一个超时时间* 该线程开始运行后,经过指定超时时间,* 该线程会抛出一个未检查异常通知调用该线程的程序超时* 在超时结束前可以调用该类的cancel方法取消计时* @author solonote*/public class ... -
java webservice超时设置_java 设置WebService超时
2021-02-27 13:55:55//上面两种方式都是通过控制底层的http连接来达到timeout控制,如果超时会抛出 java.net.SocketTimeoutException: Read timed out. //3,jax-ws的客户端:同样利用CXF的ClientProxy控制http连接: URL wsdlURL = new ... -
curl超时设置java_java如何设置超时时间
2021-03-14 12:37:50java如何设置超时时间[2021-02-01 12:11:14]简介:PHP请求远程地址设置超时时间的方法:1、【file_get_contents】请求超时设置;2、fopen请求超时设置;3、curl请求超时设置。【相关学习推荐:php编程(视频)】PHP请求... -
java socket超时时间_Java设置socket超时时间
2021-02-12 19:07:22网上看了写文章,发现很多设置socket超时时间使用的是:setSoTimeout这个方法,但这个不是设置超时方法,具体的作用自己google一下。socket有一个connect的方法,里面的最后一个参数就是超时的参数:/*** Connects ... -
java 设置请求超时时间_java设置http请求超时时间
2021-02-26 21:16:55java设置http请求超时时间 Java 设置Http 请求超时时间 Java中可以使用HttpURLConnection来请求WEB资源。 HttpURLConnection对象不能直接构造,需要通过URL.openConnection来获 得HttpURLConnection对象,示例代码... -
java webservice 超时_java 设置WebService超时
2021-02-12 15:03:54//上面两种方式都是通过控制底层的http连接来达到timeout控制,如果超时会抛出 java.net.SocketTimeoutException: Read timed out. //3,jax-ws的客户端:同样利用CXF的ClientProxy控制http连接: URL wsdlURL = new ... -
java socket超时_Java中对Socket设置超时时间
2021-02-12 13:23:12java中对Socket设置超时时间主要有以下两种方式,我们来看一下:(推荐:java视频教程)方式1:Socket s=new Socket();s.connect(new InetSocketAddress(host,port),10000);方式2:Socket s=new Socket("127.0.0.1",... -
java http超时_Java HTTP请求时设置超时
2021-03-22 11:23:43[http是无状态的连接,不像socket可以有timeout的异常,因此在判断...声明一个booleaHTTP请求时设置超时时间是明智的,避免死等。HttpPost request = new HttpPost(requestUrl);HttpClient client = new DefaultHtt... -
java url 设置超时_java - HttpURLConnection超时设置
2021-02-28 10:30:42如果HTTP连接没有超时,你可以在后台线程本身(AsyncTask,Service等)中实现超时检查器,下面的类是Customize AsyncTask的一个例子,它在一段时间后超时public abstract class AsyncTaskWithTimer extendsAsyncTask {... -
java 设置session超时_Java设置session超时(失效)的时间
2021-02-28 17:04:57在web容器中设置(以tomcat为例)在tomcat-7.0\conf\web.xml中设置,以下是tomcat7.0中默认配置:30tomcat默认session超时时间为30分钟,可以根据需要修改,负数或0为不限制session失效时间这里要... -
java jdbc超时设置_java – 为JDBC连接设置网络超时
2021-02-26 16:59:42我正在尝试使用Java设置网络超时我的Oracle数据库连接.但是,我收到了一个错误.下面是示例代码,它是相应的例外.try{conn = new Database("oracle").connect();conn.setNetworkTimeout(null, 30000); //I don't have ... -
java设置http超时时间_Java设置Http请求超时时间
2021-02-12 20:08:10Java中可以使用HttpURLConnection来请求WEB资源。HttpURLConnection对象不能直接构造,需要通过URL.openConnection()来获得HttpURLConnection对象,示例代码如下:String szUrl = "http://www.zhixing123.cn/";URL ... -
java接口超时设置_SpringBoot设置接口超时时间
2021-03-09 05:25:45SpringBoot设置接口访问超时时间有两种方式一、在配置文件application.properties中加了spring.mvc.async.request-timeout=20000,意思是设置超时时间为20000ms即20s,二、还有一种就是在config配置类中加入:public... -
java方法设置超时退出_java 方法的执行时间监控 设置超时(Future 接口)
2021-03-17 03:54:08java 方法的执行时间监控 设置超时(Future 接口)import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent... -
java socket超时时间_Socket设置超时时间
2021-02-28 09:04:11主要有以下两种方式,我们来看一下方式1:Socket s=newSocket(); s.connect(new InetSocketAddress(host,port),10000);...那么这两种方式设置的超时时间各自代表了什么意义呢?有什么区别呢?第1种方式我们先来看一... -
java url 设置超时_HttpURLConnection超时设置
2021-02-28 10:30:38慕斯王如果HTTP连接没有超时,则可以在后台线程本身(AsyncTask,Service等)中实现超时检查器,以下类是Customize AsyncTask的示例,该示例在特定时间段后超时public abstract class AsyncTaskWithTimer extends ... -
java设置页面超时时间_客户端设置超时时间真的很重要
2021-02-26 09:33:57如果当时客户端没有设置超时时间的话,会在客户端中产生级联故障。先用一张图来说明一下。聚合层除了调用购物车微服务,还调用了营销系统微服务。如果购物车服务的接口响应时间很慢,而客户端聚合层调用购物车服务时...