引用网址:https://blog.csdn.net/a9529lty/article/details/42711029
前段时间在搞一个批量处理程序,涉及到多线程操作。但是后台服务很不给力,并发一大常常就挂了,长时间不给返回,导致我的程序也挂死在那里……
那么能不能设置一段代码执行的超时时间呢?如果处理超时就忽略该错误继续向下执行。
可是在网上搜了大半天,找到的都是无用的代码,根本不能用。
查了大量资料后发现,java早已经给我们提供了解决方案。jdk1.5自带的并发库中Future类就能满足这个需求。Future类中重要方法包括get()和cancel()。get()获取数据对象,如果数据没有加载,就会阻塞直到取到数据,而 cancel()是取消数据加载。另外一个get(timeout)操作,表示如果在timeout时间内没有取到就失败返回,而不再阻塞。
到这里,此问题就迎刃而解了。废话不多说,直接上代码:
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import com.sun.corba.se.impl.orbutil.closure.Future;
import com.sun.corba.se.impl.orbutil.threadpool.TimeoutException;
public class ThreadTest {
public static void main(String[] args) throws InterruptedException,
ExecutionException {
final ExecutorService exec = Executors.newFixedThreadPool(1);
Callable<String> call = new Callable<String>() {
public String call() throws Exception {
//开始执行耗时操作
Thread.sleep(1000 * 5);
return "线程执行完成.";
}
};
try {
Future<String> future = exec.submit(call);
String obj = future.get(1000 * 1, TimeUnit.MILLISECONDS); //任务处理超时时间设为 1 秒
System.out.println("任务成功返回:" + obj);
} catch (TimeoutException ex) {
System.out.println("处理超时啦....");
ex.printStackTrace();
} catch (Exception e) {
System.out.println("处理失败.");
e.printStackTrace();
}
// 关闭线程池
exec.shutdown();
}
}
注意,以上代码需要 1.5 以上的 jdk 才可编译。
执行后可以发现抛出了 TimeoutException ,打印出了"处理超时啦…" 的文字,在此处可进行超时后的处理。
=end=华丽的分割线==============================
模拟远程超时、重试调用:
远程业务处理类:
package com.xxx.xxx;
import java.util.HashMap;
import java.util.Map;
/**
* 远程耗时处理类
*/
public class WMSProcess {
//幂等校验map
static Map<String, String> resultMap = new HashMap<>(20);
//用于记录返回的是第几次调用的结果
static int count = 1;
/**
* 模拟wms进行下游处理
* @param uuidKey
* @return
*/
public String process(String uuidKey){
System.out.println("--------------WMSProcess-----begin");
if(null == resultMap.get(uuidKey)){ //没有对应uuidKey,证明是新业务的第一次请求,开始处理
/**
* 由于处理可能耗时较长,先向resultMap中放一个uuidKey键对应的executing值
* 标识业务正在处理中,第二次相同uuidKey的请求到达时虽然还不能直接取得第一次的处理结果
* 但通过此标识请求可以感知第一次请求已到达,且任务正在处理中,则后面程序就会等待第一次的处理结果
* 直到拿到第一次请求的处理完成结果并返回。
*/
resultMap.put(uuidKey, "executing");
System.out.println("--------------WMSProcess-----executing");
try {
Thread.sleep(1000*15);
resultMap.put(uuidKey, "success");
System.out.println("--------------WMSProcess-----end---success");
return "success"+(count++);
}catch (Exception e){
resultMap.put(uuidKey, "error");
System.out.println("--------------WMSProcess-----end---error");
return "error"+(count++);
}
}else { //uuidKey存在,证明已有相同请求在处理,之前返回第一次处理结果
String value = resultMap.get(uuidKey);
if(value.equals("executing")){ //证明第一次仍在处理中,循环取第一次处理完成结果,并返回
while (true){
value = resultMap.get(uuidKey);
System.out.println("--wmsMap waiting");
if(!value.equals("executing")){
System.out.println("--------------WMSProcess-----return from waiting map ");
return value+(count++);
}
try {
Thread.sleep(1000);
}catch (Exception e){
return "exception";
}
}
}else {//第一次处理完成,直接返回第一次的处理结果
System.out.println("--------------WMSProcess-----return from map ");
return value+(count++);
}
}
}
}
本地业务处理类:
package com.xxx.xxx;
import java.util.UUID;
import java.util.concurrent.*;
/**
* 模拟本地业务处理逻辑类
*/
public class ECLPProcess {
/**
* 本地业务处理方法
*/
public void uploadPoBox(){
System.out.println("---------ECLP上传箱明细开始-----前置处理");
downToWMS();
System.out.println("---------ECLP上传箱明细结束-----后置处理");
}
/**
* 本地业务需要的远程处理
*/
public void downToWMS(){
WMSProcess wmsProcess = new WMSProcess();
System.out.println("-------开始调用WMS接口");
String uuidKey = UUID.randomUUID().toString();
ExecutorService exec = Executors.newFixedThreadPool(1);
Callable<String> call = new Callable<String>() {
public String call() throws Exception {
return wmsProcess.process(uuidKey);
}
};
Future<String> future = exec.submit(call);
String result = downAndReturn(exec, call, future, 20);
System.out.println("-------调用WMS接口结束,返回结果为:"+result);
}
/**
* 调用远程接口,取得处理结果,3秒内无响应则再次调用,直到取得返回结果或重试次数超过retryNum,抛出异常
* @param exec 线程池对象
* @param call 远程接口调用线程
* @param future 线程预处理结果对象
* @param retryNum 重试次数
* @return
*/
public String downAndReturn(ExecutorService exec, Callable<String> call, Future<String> future, int retryNum) {
String result;
try {
if(retryNum < 1){
throw new RuntimeException("----------wms下发返回处理超时");
}
result = future.get(1000 * 3, TimeUnit.MILLISECONDS);
} catch (TimeoutException ex) {
future = exec.submit(call);
result =downAndReturn(exec, call, future, --retryNum);
} catch (Exception e) {
throw new RuntimeException(String.format("ECLPProcess.downAndReturn 出现异常:{%s}", e));
} finally {
exec.shutdown();
}
return result;
}
}
测试类:
package com.xxx.xxx;
public class Test000 {
public static void main(String[] args){
ECLPProcess eclpProcess = new ECLPProcess();
eclpProcess.uploadPoBox();
}
}
end华丽的分割线===============
如果对线程、线程池不太了解,向下继续
引用:https://www.cnblogs.com/Steven0805/p/6393443.html
Java线程池ExecutorService
开篇前,我们先来看看不使用线程池的情况:
new Thread的弊端
执行一个异步任务你还只是如下new Thread吗?
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
}
}).start();
那你就太out了,new Thread的弊端如下:
a. 每次new Thread新建对象性能差。
b. 线程缺乏统一管理,可能无限制新建线程,相互之间竞争,及可能占用过多系统资源导致死机或oom。
c. 缺乏更多功能,如定时执行、定期执行、线程中断。
相比new Thread,Java提供的四种线程池的好处在于:
a. 重用存在的线程,减少对象创建、消亡的开销,性能佳。
b. 可有效控制最大并发线程数,提高系统资源的使用率,同时避免过多资源竞争,避免堵塞。
c. 提供定时执行、定期执行、单线程、并发数控制等功能。
一 Java通过Executors提供四种线程池,分别为:
newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。
newFixedThreadPool 创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池,支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
二、 ExecutorService 的submit() 与execute()区别
1、接收的参数不一样 submit()可以接受runnable和callable 有返回值
execute()接受runnable 无返回值
2、submit有返回值,而execute没有
Method submit extends base method Executor.execute by creating and returning a Future that can be used to cancel execution and/or wait for completion.
用到返回值的例子,比如说我有很多个做validation的task,我希望所有的task执行完,然后每个task告诉我它的执行结果,是成功还是失败,如果是失败,原因是什么。
3、submit方便Exception处理
There is a difference when looking at exception handling. If your tasks throws an exception and if it was submitted with execute this exception will Go to the uncaught exception handler (when you don’t have provided one explicitly, the default one will just print the stack trace to System.err). If you submitted the task with submit any thrown exception, checked or not, is then part of the task’s return status. For a task that was submitted with submit and that terminates with an exception, the Future.get will rethrow this exception, wrapped in an ExecutionException.
意思就是如果你在你的task里会抛出checked或者unchecked exception,而你又希望外面的调用者能够感知这些exception并做出及时的处理,那么就需要用到submit,通过捕获Future.get抛出的异常。
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
public class ExecutorServiceTest {
public static void main(String[] args) {
ExecutorService executorService = Executors.newCachedThreadPool();
List<Future<String>> resultList = new ArrayList<Future<String>>();
// 创建10个任务并执行
for (int i = 0; i < 10; i++) {
// 使用ExecutorService执行Callable类型的任务,并将结果保存在future变量中
Future<String> future = executorService.submit(new TaskWithResult(i));
// 将任务执行结果存储到List中
resultList.add(future);
}
executorService.shutdown();
// 遍历任务的结果
for (Future<String> fs : resultList) {
try {
System.out.println(fs.get()); // 打印各个线程(任务)执行的结果
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
executorService.shutdownNow();
e.printStackTrace();
return;
}
}
}
}
class TaskWithResult implements Callable<String> {
private int id;
public TaskWithResult(int id) {
this.id = id;
}
/**
* 任务的具体过程,一旦任务传给ExecutorService的submit方法,则该方法自动在一个线程上执行。
*
* @return
* @throws Exception
*/
public String call() throws Exception {
System.out.println("call()方法被自动调用,干活!!! " + Thread.currentThread().getName());
if (new Random().nextBoolean())
throw new TaskException("Meet error in task." + Thread.currentThread().getName());
// 一个模拟耗时的操作
for (int i = 999999999; i > 0; i--)
;
return "call()方法被自动调用,任务的结果是:" + id + " " + Thread.currentThread().getName();
}
}
class TaskException extends Exception {
public TaskException(String message) {
super(message);
}
}
执行的结果类似于:
call()方法被自动调用,干活!!! pool-1-thread-1
call()方法被自动调用,干活!!! pool-1-thread-2
call()方法被自动调用,干活!!! pool-1-thread-3
call()方法被自动调用,干活!!! pool-1-thread-5
call()方法被自动调用,干活!!! pool-1-thread-7
call()方法被自动调用,干活!!! pool-1-thread-4
call()方法被自动调用,干活!!! pool-1-thread-6
call()方法被自动调用,干活!!! pool-1-thread-7
call()方法被自动调用,干活!!! pool-1-thread-5
call()方法被自动调用,干活!!! pool-1-thread-8
call()方法被自动调用,任务的结果是:0 pool-1-thread-1
call()方法被自动调用,任务的结果是:1 pool-1-thread-2
java.util.concurrent.ExecutionException: com.cicc.pts.TaskException: Meet error in task.pool-1-thread-3
at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:222)
at java.util.concurrent.FutureTask.get(FutureTask.java:83)
at com.cicc.pts.ExecutorServiceTest.main(ExecutorServiceTest.java:29)
Caused by: com.cicc.pts.TaskException: Meet error in task.pool-1-thread-3
at com.cicc.pts.TaskWithResult.call(ExecutorServiceTest.java:57)
at com.cicc.pts.TaskWithResult.call(ExecutorServiceTest.java:1)
at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
at java.util.concurrent.FutureTask.run(FutureTask.java:138)
at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
at java.lang.Thread.run(Thread.java:619)
可以看见一旦某个task出错,其它的task就停止执行。
三、shotdown() showdownNow()区别
可以关闭 ExecutorService,这将导致其拒绝新任务。提供两个方法来关闭 ExecutorService。
shutdown() 方法在终止前允许执行以前提交的任务,
shutdownNow() 方法阻止等待任务启动并试图停止当前正在执行的任务。在终止时执行程序没有任务在执行,也没有任务在等待执行,并且无法提交新任务。关闭未使用的 ExecutorService 以允许回收其资源。
一般分两个阶段关闭 ExecutorService。第一阶段调用 shutdown 拒绝传入任务,然后调用 shutdownNow(如有必要)取消所有遗留的任务
// 启动一次顺序关闭,执行以前提交的任务,但不接受新任务。
threadPool.shutdown();
四、Runnable()与Callable()区别
如果是一个多线程协作程序,比如菲波拉切数列,1,1,2,3,5,8…使用多线程来计算。
但后者需要前者的结果,就需要用callable接口了。
callable用法和runnable一样,只不过调用的是call方法,该方法有一个泛型返回值类型,你可以任意指定。
runnable接口实现的没有返回值的并发编程。
callable实现的存在返回值的并发编程。(call的返回值String受泛型的影响) 使用Future获取返回值。
(1). newCachedThreadPool
创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。示例代码如下:
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
for (int i = 0; i < 10; i++) {
final int index = i;
try {
Thread.sleep(index * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
cachedThreadPool.execute(new Runnable() {
@Override
public void run() {
System.out.println(index);
}
});
}
线程池为无限大,当执行第二个任务时第一个任务已经完成,会复用执行第一个任务的线程,而不用每次新建线程。
(2). newFixedThreadPool
创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。示例代码如下:
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int index = i;
fixedThreadPool.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
因为线程池大小为3,每个任务输出index后sleep 2秒,所以每两秒打印3个数字。
定长线程池的大小最好根据系统资源进行设置。如Runtime.getRuntime().availableProcessors()。可参考PreloadDataCache。
(3) newScheduledThreadPool
创建一个定长线程池,支持定时及周期性任务执行。延迟执行示例代码如下:
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
scheduledThreadPool.schedule(new Runnable() {
@Override
public void run() {
System.out.println("delay 3 seconds");
}
}, 3, TimeUnit.SECONDS);
表示延迟3秒执行。
定期执行示例代码如下:
scheduledThreadPool.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
System.out.println("delay 1 seconds, and excute every 3 seconds");
}
}, 1, 3, TimeUnit.SECONDS);
表示延迟1秒后每3秒执行一次。
ScheduledExecutorService比Timer更安全,功能更强大,后面会有一篇单独进行对比。
(4)、newSingleThreadExecutor
创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。示例代码如下:
ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
for (int i = 0; i < 10; i++) {
final int index = i;
singleThreadExecutor.execute(new Runnable() {
@Override
public void run() {
try {
System.out.println(index);
Thread.sleep(2000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
}
结果依次输出,相当于顺序执行各个任务。
现行大多数GUI程序都是单线程的。Android中单线程可用于数据库操作,文件操作,应用批量安装,应用批量删除等不适合并发但可能IO阻塞性及影响UI线程响应的操作。
总结:
(1)使用ExecutorService的submit函数由于execute函数
(2)异常如何处理,异常后其他task停止