mysql 线程池 超时_关于使用线程池控制任务超时的问题

最新推荐文章于 2023-07-08 11:02:54 发布
最新推荐文章于 2023-07-08 11:02:54 发布
阅读量505 收藏
点赞数
文章标签： mysql 线程池 超时
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_35084652/article/details/113937694
版权
本文讨论了在使用线程池处理任务时如何控制超时和中断线程。传统的JDK stop()方法由于安全性问题已被弃用，建议使用中断机制，由任务本身决定中断点并处理中断。在遇到超时时，调用future.cancel(true)来中断任务。同时，示例代码展示了如何在任务中检查中断状态，确保数据一致性。此外，还提到在for循环中使用Thread.currentThread().interrupted()进行中断判断的重要性。
摘要由CSDN通过智能技术生成

0

0

采纳的答案

引用

在这个job中的call方法应为有for()循环可以找到在哪中断线程，但是如果只是在连接数据库的话，那就无法知道执行到哪，应该加入中断线程的代码，这应该在外面控制，而不应该在job里面实现中断

线程的中断在JDK1.0版本中提供了stop()方法，但这个方法极度不安全，会不管

当前对象的状态而直接释放所有的monitor，结束线程，会导致对象处于错误的状态。

所以已经不被推荐使用。

试想，有个任务，A向B转账10000￥，需要先从A账户上扣款10000￥，再将B账号加

10000￥，如果A账号扣款完，这是从外面强行杀死线程，会导致什么后果？

中止一个线程最好的方式就是使用中断，在外面通知线程中断，线程将中断状态设置

为true，而具体是否要中断，中断时需要如何处理以保证数据状态是正确的，这些

应交给任务自己处理。

在什么地方控制中断，应该任务中控制，由你的业务逻辑决定，就算是

操作数据库也一样可以设置中断点，或者说更应该判断中断点，来决定是否回滚

事务。

2011年9月01日 18:25

0

0

String N= "";

String M= "";

String id= "";

String pwd = "";

protected void doPost(HttpServletRequest req, HttpServletResponse res)

throws ServletException, IOException

{

this.M = req.getParameter("M").trim();

this.N= req.getParameter("N").trim();

this.id = req.getParameter("id").trim();

this.pwd = req.getParameter("pwd").trim();

/................../

}

当多个系统同时调用该servlet的时候，出现了servlet的非线程安全的问题。比如有两个系统同时调用该servlet，代码中的N、M、id、pwd的值会出现，一个线程的数据被另一个线程的数据“覆盖”的问题。

我的问题是，第一：是否跟这几个变量是全部变量有关，如果设置为局部变量会出现这个问题吗？第二：使用多个servlet能解决这个问题，但是是最好的办法吗？

2011年9月15日 11:34

0

0

楼主cancle地方不对，中断异常后返回也有问题，仔细看下面：public class Test {

private static ExecutorService executor = Executors.newCachedThreadPool();// 定义一个线程池

/**

* @param args

*/

public static void main(String[] args) {

Boolean result = false;

Future future = executor.submit(new MyJob());// 将任务提交到线程池中

try {

result = future.get(20, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

// future.cancel(true);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

System.out.println("Time is out");// 抛出超时异[size=xx-small][/size]常时打印

//executor.shutdown();// 出现异常即可终止任务。

[color=red]future.cancel(true);[/color]

}

//executor.shutdown();

System.out.println(result);

}

}

class MyJob implements Callable {

@SuppressWarnings("static-access")

@Override

public Boolean call() {

// do job here

//long startTime = System.currentTimeMillis();

//for (int i = 0; System.currentTimeMillis() - startTime < 2000; i++) {

//System.out.println(i);

//}

try {

Thread.currentThread().sleep(300);

} catch (InterruptedException e) {

e.printStackTrace();

[color=red]return false; [/color]

}

// 模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

2011年9月08日 19:30

0

0

你对自己要做什么可能很清楚，但你对线程池能做什么确实很模糊，自己把自己绕晕了！！！

回滚事务，如果超时事务回滚到操作以前的场景！

2011年9月07日 17:31

0

0

改了一下你原先的代码import java.util.concurrent.ExecutionException;

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;

import java.util.concurrent.Callable;

public class My {

// 业务job

// 实现Callable接口

static class MyJob implements Callable {

public Boolean call() {

// do job here

long startTime = System.currentTimeMillis();

for (int i = 0; System.currentTimeMillis() - startTime < 2000; i++) {

//测试当前线程是否已经中断,配合future.cancel(true)

if (Thread.interrupted())

return false;

}// 模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

private static ExecutorService executor = Executors.newCachedThreadPool();// 定义一个线程池

/**

* @param args

*/

public static void main(String[] args) {

Boolean result = false;

Future future = executor.submit(new MyJob());// 将任务提交到线程池中

try {

result = future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {// 超时异常

System.out.println("Time is out");

future.cancel(true);// 中断执行此任务的线程

}

}

}

测试通过，不会打印"continue..."

2011年9月05日 17:43

0

0

package dl.java.iteye;

import java.util.concurrent.ExecutionException;

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;

import java.util.concurrent.Callable;

public class My {

private static ExecutorService executor = Executors.newCachedThreadPool();// 定义一个线程池

/**

* @param args

*/

public static void main(String[] args) {

Boolean result = false;

MyJob job = new MyJob();

Future future = executor.submit(job);// 将任务提交到线程池中

try {

result = future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

System.out.println("Time is out");// 抛出超时异[size=xx-small][/size]常时打印

job.thread.stop();

}

}

//业务job

//实现Callable接口

static class MyJob implements Callable {

public Thread thread = null;

@Override

public Boolean call() throws Exception {

//do job here

long startTime = System.currentTimeMillis(); //获取当前运行线程

thread = Thread.currentThread();

for(int i=0;System.currentTimeMillis()-startTime<2000;i++){}//模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

}

这是一个案例，你根据实际情况，修改吧。你可以复制，运行一下。打印结果：

Time is out

2011年9月05日 15:19

0

0

引用

xiaoyang0601 写道

一个这种的办法是获取MyJob当前的线程；在MyJob对象中声明一个变量thread

Java代码

import java.util.concurrent.Callable;

//实现Callable接口

public class MyJob implements Callable {

public Thread thread = null;   //定义一个当前任务线程

@Override

public Boolean call() throws Exception {

//do job here

long startTime = System.currentTimeMillis();

thread = Thread.currentThread();//获取当前线程，，外界可以访问

for(int i=0;System.currentTimeMillis()-startTime<2000;i++){}//模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

import java.util.concurrent.Callable;

//实现Callable接口

public class MyJob implements Callable {

public Thread thread = null;

@Override

public Boolean call() throws Exception {

//do job here

long startTime = System.currentTimeMillis();

thread = Thread.currentThread();//获取当前线程for(int i=0;System.currentTimeMillis()-startTime<2000;i++){}//模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

在My对象中当超时，就对该工作任务的线程进行终止。

Java代码

Boolean result = false;

MyJob job = new MyJob();//将提交的任务

Future future = executor.submit(job);// 将任务提交到线程池中

try {

result = future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

//          future.cancel(true);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

System.out.println("Time is out");// 抛出超时异[/size]常时打印

job.thread.stop();//访问MyJob线程。

}

Boolean result = false;

MyJob job = new MyJob();Future future = executor.submit(job);// 将任务提交到线程池中

try {

result = future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

//future.cancel(true);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

System.out.println("Time is out");// 抛出超时异[size=xx-small]常时打印

job.thread.stop();}

我也想用stop(),但是job.thread取不到该线程啊

能访问到啊。你仔细看看代码。在MyJob中声明一个任务线程，这个任务线程就是当前任务的，在My对象中，声明一个MyJob job = new MyJob();

Future future = executor.submit(job);//

在超时异常代码中

job.thread.stop();是可以访问的。你或许访问修饰符有误。

还有你提的这个问题，中超时不再处理以后的任务，但这个超时的后的任务放在任务中，欠妥，可以提取出来，进行重构，先进性必要的超时处理，如果没有超时在My对象中进行处理业务，如果超时就不再处理。

2011年9月02日 17:10

0

0

一般涉及到网络连接的地方，都会提供超时接口，getConnection也不例外，

不需要自己来控制超时。/**

* Sets the maximum time in seconds that a driver will wait

* while attempting to connect to a database.

*

* @param seconds the login time limit in seconds; zero means there is no limit

* @see #getLoginTimeout

*/

public static void setLoginTimeout(int seconds) {

loginTimeout = seconds;

}

2011年9月02日 16:12

0

0

引用

难道就无解了吗？

暂时没想出来，晚上回去我有开发环境了，我再试试看

2011年9月02日 15:34

0

0

引用

例子很好，不过要在任务中控制，不知道该如何在任务中设置中断点

比如说简单的获取数据库connection，我要在规定时间内判断，若没连接成功就中断线程

因为你获得不到这个JOB所在的线程，所以你没有办法来中断它的。

2011年9月02日 15:26

0

0

引用

我也想用stop()

stop() 已经是不推荐使用了，就算你获得了JOB所在的线程，请也别使用这个方法

2011年9月02日 14:57

0

0

一个这种的办法是获取MyJob当前的线程；在MyJob对象中声明一个变量threadimport java.util.concurrent.Callable;

//实现Callable接口

public class MyJob implements Callable {

[b] public Thread thread = null;[/b]

@Override

public Boolean call() throws Exception {

//do job here

long startTime = System.currentTimeMillis();

[b]thread = Thread.currentThread();[/b]//获取当前线程for(int i=0;System.currentTimeMillis()-startTime<2000;i++){}//模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

在My对象中当超时，就对该工作任务的线程进行终止。

Boolean result = false;

[b]MyJob job = new MyJob();[/b]Future future = executor.submit(job);// 将任务提交到线程池中

try {

result = future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

//future.cancel(true);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

System.out.println("Time is out");// 抛出超时异[size=xx-small][/size]常时打印

[b]job.thread.stop();[/b]}

2011年9月02日 13:42

0

0

我习惯的做法是在工作线程内部设置一个boolean变量，如果外界想让线程结束就设置一下这个变量。在线程内部会判断这个变量，看是否要退出。

2011年9月01日 21:05

0

0

引用

public class MyJob implements Callable {

@Override

public Boolean call() {

//do job here

long startTime = System.currentTimeMillis();

for(int i=0;System.currentTimeMillis()-startTime<2000;i++){}//模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

你这个测试任务写的有问题，根本没有控制中断，for循环会一直执行到结束。

要在循环中加入线程中断的判断。

Thread.currentThread().interrupted()

引用

public class MyJob implements Callable {

@Override

public Boolean call() {

//do job here

long startTime = System.currentTimeMillis();

for(int i=0;System.currentTimeMillis()-startTime<2000;i++){

if(Thread.currentThread().interrupted()){

return false;

}

}//模拟业务执行超过2000毫秒，即已经超时

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

return true;

}

}

在外面执行future.cancel(true)这时就能结束任务了。

2011年9月01日 17:55

0

0

主要是要实现自己的终止策略

比如在for循环中可以加入这样的判断for(;;){

if(Thread.currentThread().isInterrupted())

return false; //这就是来响应future.cancel啊，你不响应他，咋停啊

}

Java 并发编程实践这本书，看了基本上可以解决大部分问题了

2011年9月01日 17:21

0

0

引用

使用thread能实现吗？还要有返回值的

使用 Thread.sleep() 的话，你可以这么写：

try{

Thread.sleep(2000);

} catch (InterruptedException e) {

return false;

}

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

return true;

2011年9月01日 17:18

0

0

你能把你的for循环里面模仿超时的语句贴出来吗？我用的是Thread.sleep();

2011年9月01日 17:05

0

0

引用

是不是使用线程池提交，线程池将任务分配给多个线程处理了，cancel()后仍然将任务分配给其他的线程执行？这个需要看源码啊。但我认为，应该是针对每一个被submit上去的任务开一个线程来执行

2011年9月01日 17:02

0

0

引用

res为true

呃，那这就奇怪了啊。明明任务已经被取消了，怎么还会打印出下面那句话呢。郁闷啊。。。

2011年9月01日 16:59

0

0

我验证过了在"time is out"的打印后面加future.cancel(true);是可行的，不知道你怎么验证的？

} catch (TimeoutException e) {

System.out.println("Time is out");//抛出超时异[size=xx-small][/size]常时打印

future.cancel(true);

}

2011年9月01日 16:40

0

0

public class My {

private static ExecutorService executor = Executors.newCachedThreadPool();// 定义一个线程池

public static void main(String[] args) {

Future future = executor.submit(new MyJob());// 将任务提交到线程池中

executor.shutdown(); //关闭线程池 不允许再提交任务，并不是关闭线程池中的线程

try {

future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

future.cancel(true);//关闭超时的这个任务

//executor.shutdownNow(); //因为这个任务超时，终止了所有的线程.

System.out.println("Time is out");// 抛出超时异[size=xx-small][/size]常时打印

}

}

/**

*

* 任务。其实完全可以或应该在任务重控制自己何时超时，

* 当然我顺着你的思路来了

*/

public static class MyJob implements Callable {

public Boolean call() throws Exception {

long startTime = System.currentTimeMillis();

try {

TimeUnit.MILLISECONDS.sleep(200);

} catch (InterruptedException e) {

return false; //这里要响应future的中断啊，

//返回false吧，或者超时了抛个异常也行，这就是所谓的中断策略

//Java5以后的线程终止方法被废了，很多时候终止策略应该自己来实现

}

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

return true;

}

}

}

2011年9月01日 16:28

0

0

catch (TimeoutException e) {

System.out.println("Time is out");//抛出超时异常时打印

boolean res = future.cancel(true);

System.out.println("res:" + res);

}

你这么改一下，看看 res 的值是true 还是 false;

2011年9月01日 15:59

0

0

public class My {

private static ExecutorService executor = Executors.newCachedThreadPool();// 定义一个线程池

/**

* @param args

*/

public static void main(String[] args) {

Boolean result = false;

Future future = executor.submit(new MyJob());// 将任务提交到线程池中

try {

result = future.get(200, TimeUnit.MILLISECONDS);// 设定在200毫秒的时间内完成

//future.cancel(true);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (ExecutionException e) {

e.printStackTrace();

} catch (TimeoutException e) {

System.out.println("Time is out");// 抛出超时异[size=xx-small][/size]常时打印

executor.shutdown();//出现异常即可终止任务。

}

executor.shutdown();

System.out.println(result);

}

}

需要调用 executor.shutdown();

终止当前线程任务。

2011年9月01日 13:51

0

0

在for循环后面抛个异常这样挺好哈

if (System.currentTimeMillis() - startTime >=2000)

throw new TimeoutException();

或者在你的job里实现取消策略，在需要时自己取消。

Future future = executor.submit(new MyJob());// 将任务提交到线程池中

executor.shutdown();//没人提交了该shutdown()了吧

2011年9月01日 13:07

0

0

引用

catch (TimeoutException e) {

System.out.println("Time is out");//抛出超时异[size=xx-small][/size]常时打印

}

在你的System.out.print()语句下，添加一行代码：

future.cancel(true);

看看行不行

2011年9月01日 12:55

0

0

在外面控制时间，200毫秒后，执行

future.cancel(true);

2011年9月01日 12:09

0

0

这好像没什么好办法

future.get(200, TimeUnit.MILLISECONDS)这个只是等结果的时间

2011年9月01日 11:54

8aae5bd772e46b5c641c69ae703a63c3.png

315

0

0

1

赛博格Cyborg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用swoole搭建mysql线程池_Swoole MySQL 连接池的实现
weixin_39814393的博客
02-05 187
概述这是关于 Swoole 入门学习的第八篇文章：Swoole MySQL 连接池的实现。收到读者的咨询，这情况大家可能也会有，所以就在这说说：“亮哥，我今年30岁了，有点中年危机，最近有点焦虑，发现工作虽然很忙，但是没感觉能力有所提升，整天都有写不完的业务代码，时间紧有时代码质量也不怎么样，知道还有很多改进空间，但一直没时间改，主要是后面项目压着，马上又要进入开发了，这种情况怎么办？”首先，我是...
线程池和超时线程的实现（附源码）
11-27
在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 下面是一个线程池例子，经测试绝对可行：
【Java并发】线程池多线程调用 限定超时时间的future.get()串行阻塞式运行
锥栗的博客
06-05 7785
线程池多线程任务调用，串行阻塞式运行，虽然慢但稳妥要求单个线程运行时必须要有超时时间，超时则放弃运行下一个任务这里的实现仅能用，不完善Main.java 运行 运行结果：
java 线程池超时_Java线程池停止超时任务
weixin_39615991的博客
02-12 871
问题通过ScheduledExecutorService线程池定时调度一个任务，如果其中一次调度任务卡住的话，不仅这次调度失败，而且整个线程池也会停在这次调度上。解决思路Future定时线程池没有任务调度的超时策略，但是Future有。Future(java.util.concurrent Interface Future)表示异步计算的结果。Future接口提供了检查计算是否完成、检查计算是否被...
Java定时线程池停止超时任务
weixin_30357231的博客
12-05 193
一、背景题主最近遇到一个问题，本来通过ScheduledExecutorService线程池定时调度一个任务。奈何不知道为啥跑了2个多月，其中一个任务Hang住了，原本定时的任务则出现了问题。 关于定时线程池，好多人认为设置好频率（比如1Min），它会按照这个间隔按部就班的工作。但是，如果其中一次调度任务卡住的话，不仅这次调度失败，而且整个线程池也会停在这次调度上。 我们先从一个例子试着复现下...
mysql 线程池 超时_java 线程池 超时中断
weixin_33571513的博客
02-07 96
import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;import java.util.concurrent.TimeUnit...
Django mysql 多线程_Django异步任务线程池
weixin_42525738的博客
01-19 474
当数据库数据量很大时(百万级)，许多批量数据修改请求的响应会非常慢，一些不需要即时响应的任务可以放到后台的异步线程中完成，发起异步任务的请求就可以立即响应选择用线程池的原因是：线程比进程更为可控。不像子进程，子线程会在所属进程结束时立即结束。线程可共享内存。请求任务异步处理的原理使用python manage.py runserver模式启动的Django应用只有一个进程，对于每个请求，主线程会开...
java线程池导致mysql_记录一个mysql的bug以及关于线程池的问题
06-09
关于 Java 线程池导致 MySQL 的 Bug，可能是由于线程池中的线程数量过多，导致 MySQL 连接池被耗尽，从而出现连接超时或者连接泄露的情况。这种情况下，可以通过优化线程池的配置，增加 MySQL 连接池的大小，或者...
使用线程池控制Phoenix连接超时
匿名
12-11 3113
HBase – Hadoop Database，一个NoSQL数据库，可存储大量非关系型数据，利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。 Phoenix是构建在HBase上的一个SQL层，能让我们用标准的JDBC API而不是HBase客户端API来对HBase数据进行操作。 HBase，可以用shell进行操作，也可以用Java api进行操作。HB
mysql 线程池怎么配置
最新发布
09-22
配置MySQL线程池后，数据库服务器将使用线程池来处理客户端的连接请求。线程池会根据线程池大小的配置，同时处理多个连接，提高数据库的并发处理能力。 需要注意的是，在配置MySQL线程池时，应根据系统的实际情况来...
一种利用线程池线程执行任务, 并能够结束超时任务的方法 (.NET实现)
永远的天空
03-25 2117
背景:前些日子写了一个利用正则表达式来提取内容的程序,要求正则表达式可以灵活地配置,但事后在运行时发现一个问题:有的正则表达式写的效率低下,将CPU占用了100%,并且执行了很长时间也没有执行完,影响了其它任务的工作.于是想把执行正则表达式的代码放在一个可以在超时时自动中断的函数中.首先想到的是每次使用线程System.Threading.Thread来定义一个新的线程,启动并执行,然后用
线程池拒绝策略+超时机制
weixin_38277138的博客
07-08 675
线程池拒绝策略;超时机制;ForkJoinPool线程池配置拒绝策略
线程池中多线程设置超时退出监控
热门推荐
zhangjikuan的专栏
11-29 1万+
前言 在写多线程程序时，大多数情况下会先excutor创建线程池，然后再创建线程，但是对一些读数据库或者其他IO操作，容易堵住线程，此时就需要给线程设置超时时间，干掉超时的线程再重新拉起一个线程来，但是java线程创建并没有预留超时参数，研究了一下网上也没找到好的解决方案，干脆自己想办法搞了一个。 方案 监控线程往往有这么几种方案首先想到的应该就是future的get方法，有超时时间设置参数
使用sleep时，连接数据库超时解决。
weixin_34221775的博客
08-28 605
2019独角兽企业重金招聘Python工程师标准>>> ...
线程池创建线程超时
2302_77665198的博客
04-27 2017
执行任务时，首先线程池开辟线程，之后 线程start( execute方法->addWorker-->t.start())后开始执行call方法。但从.start 到 执行call方法，需要CPU进行线程的上下文切换。则在线程为1500的并发下，即新创建线程start状态为NEW，真正运行时为RUNNABLE（start后），到call真正的调用会耗时，因CPU切换。线程池从生成线程，如果核心线程不为0，则有任务时一直生成核心线程，直至到核心线程，之后开始方队列中，最后任务多就开始开辟新线程到最大线程数。
java 线程池超时_Java定时线程池停止超时任务
weixin_31669073的博客
02-12 1995
一、背景题主最近遇到一个问题，本来通过ScheduledExecutorService线程池定时调度一个任务。奈何不知道为啥跑了2个多月，其中一个任务Hang住了，原本定时的任务则出现了问题。关于定时线程池，好多人认为设置好频率(比如1Min)，它会按照这个间隔按部就班的工作。但是，如果其中一次调度任务卡住的话，不仅这次调度失败，而且整个线程池也会停在这次调度上。我们先从一个例子试着复现下问题：p...
ExecutorService等所有线程执行完毕，并设置超时时间
u013232219的博客
04-13 1846
1、工作中遇到的业务处理需要： 例： 生产问题：生产上一个常用的会话接口，此接口内集成了5个外部接口能力（python的，Java的，其中每个接口基本耗时2~3秒），原有会话接口里是依次去调用的， 这就导致用户体验很差，因为2乘5也就是10秒，也就是说会话接口耗时10秒起步； 解决方案：将原来的依次调用，改为多线程异步调用，等所有线程的调用都处理结束后，再去统一处理封装数据，因为多线程异步的原因，一个接口调用耗时2~3秒， 则...
java 线程池超时_线程池中如何控制超时时间?
weixin_40001634的博客
02-12 5418
线程池构造方法不能控制任务的超时时间,java.util.concurrent.ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, java.util.concurrent.TimeUnit, java.util.concurrent.BlockingQueue)long, java.util.concurrent.TimeUnit设置的是超...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值