用ThreadPoolExecutor的时候，又想知道被执行的任务的执行情况，这时就可以用FutureTask。

原创不易，转载请注明出处：spring线程池ThreadPoolExecutor配置并且得到任务执行的结果

代码下载地址：http://www.zuidaima.com/share/1724478138158080.htm



ThreadPoolTask
01 package com.zuidaima.threadpool;
02  
03 import java.io.Serializable;
04 import java.util.concurrent.Callable;
05  
06 public class ThreadPoolTask implements Callable<String>, Serializable {
07  
08     private static final long serialVersionUID = 0;
09  
10     // 保存任务所需要的数据
11     private Object threadPoolTaskData;
12  
13     private static int consumeTaskSleepTime = 2000;
14  
15     public ThreadPoolTask(Object tasks) {
16         this.threadPoolTaskData = tasks;
17     }
18  
19     public synchronized String call() throws Exception {
20         // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
21         System.out.println("开始执行任务：" + threadPoolTaskData);
22         String result = "";
23         // //便于观察，等待一段时间
24         try {
25             // long r = 5/0;
26             for (int i = 0; i < 100000000; i++) {
27  
28             }
29             result = "OK";
30         } catch (Exception e) {
31             e.printStackTrace();
32             result = "ERROR";
33         }
34         threadPoolTaskData = null;
35         return result;
36     }
37 }

模拟客户端提交的线程

01 package com.zuidaima.threadpool;
02  
03 import java.util.concurrent.ExecutionException;
04 import java.util.concurrent.FutureTask;
05 import java.util.concurrent.TimeUnit;
06  
07 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
08  
09 public class StartTaskThread implements Runnable {
10  
11     private ThreadPoolTaskExecutor threadPoolTaskExecutor;
12     private int i;
13  
14     public StartTaskThread(ThreadPoolTaskExecutor threadPoolTaskExecutor, int i) {
15         this.threadPoolTaskExecutor = threadPoolTaskExecutor;
16         this.i = i;
17     }
18  
19     @Override
20     public synchronized void run() {
21         String task = "task@ " + i;
22         System.out.println("创建任务并提交到线程池中：" + task);
23         FutureTask<String> futureTask = new FutureTask<String>(
24                 new ThreadPoolTask(task));
25         threadPoolTaskExecutor.execute(futureTask);
26         // 在这里可以做别的任何事情
27         String result = null;
28         try {
29             // 取得结果，同时设置超时执行时间为1秒。同样可以用future.get()，不设置执行超时时间取得结果
30             result = futureTask.get(1000, TimeUnit.MILLISECONDS);
31         } catch (InterruptedException e) {
32             futureTask.cancel(true);
33         } catch (ExecutionException e) {
34             futureTask.cancel(true);
35         } catch (Exception e) {
36             futureTask.cancel(true);
37             // 超时后，进行相应处理
38         } finally {
39             System.out.println("task@" + i + ":result=" + result);
40         }
41  
42     }
43 }

SPRING配置文件

01 <?xml version="1.0" encoding="UTF-8"?>
02 <beans xmlns="http://www.springframework.org/schema/beans"
03     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
04     xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
05     xsi:schemaLocation="
06         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
07         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
08         http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
09         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
10         ">
11     <bean id="threadPoolTaskExecutor"
12         class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
13  
14         <!-- 核心线程数，默认为1 -->
15         <property name="corePoolSize" value="10" />
16  
17         <!-- 最大线程数，默认为Integer.MAX_VALUE -->
18         <property name="maxPoolSize" value="50" />
19  
20         <!-- 队列最大长度，一般需要设置值>=notifyScheduledMainExecutor.maxNum；默认为Integer.MAX_VALUE
21             <property name="queueCapacity" value="1000" /> -->
22  
23         <!-- 线程池维护线程所允许的空闲时间，默认为60s -->
24         <property name="keepAliveSeconds" value="300" />
25  
26         <!-- 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者 -->
27         <property name="rejectedExecutionHandler">
28             <!-- AbortPolicy:直接抛出java.util.concurrent.RejectedExecutionException异常 -->
29             <!-- CallerRunsPolicy:主线程直接执行该任务，执行完之后尝试添加下一个任务到线程池中，可以有效降低向线程池内添加任务的速度 -->
30             <!-- DiscardOldestPolicy:抛弃旧的任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
31             <!-- DiscardPolicy:抛弃当前任务、暂不支持；会导致被丢弃的任务无法再次被执行 -->
32             <bean class="java.util.concurrent.ThreadPoolExecutor$CallerRunsPolicy" />
33         </property>
34     </bean>
35 </beans>

测试类

01 package com.zuidaima.test;
02  
03 import org.junit.Test;
04 import org.junit.runner.RunWith;
05 import org.springframework.beans.factory.annotation.Autowired;
06 import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
07 import org.springframework.test.context.ContextConfiguration;
08 import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
09 import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
10  
11 import com.zuidaima.threadpool.StartTaskThread;
12  
13 @RunWith(SpringJUnit4ClassRunner.class)
14 // 指定的运行runner，并且把你所指定的Runner作为参数传递给它
15 @ContextConfiguration(locations = "classpath*:applicationContext.xml")
16 public class TestThreadPool extends AbstractJUnit4SpringContextTests {
17  
18     private static int produceTaskSleepTime = 10;
19  
20     private static int produceTaskMaxNumber = 1000;
21  
22     @Autowired
23     private ThreadPoolTaskExecutor threadPoolTaskExecutor;
24  
25     public ThreadPoolTaskExecutor getThreadPoolTaskExecutor() {
26         return threadPoolTaskExecutor;
27     }
28  
29     public void setThreadPoolTaskExecutor(
30             ThreadPoolTaskExecutor threadPoolTaskExecutor) {
31         this.threadPoolTaskExecutor = threadPoolTaskExecutor;
32     }
33  
34     @Test
35     public void testThreadPoolExecutor() {
36         for (int i = 1; i <= produceTaskMaxNumber; i++) {
37             try {
38                 Thread.sleep(produceTaskSleepTime);
39             } catch (InterruptedException e1) {
40                 e1.printStackTrace();
41             }
42             new Thread(new StartTaskThread(threadPoolTaskExecutor, i)).start();
43         }
44  
45     }
46  
47 }

原文中有些纰漏，我已经修改

项目截图(基于maven构建)

运行截图：

如果遇到cpu忙执行超过1秒的会返回null

# spring
GitHub 加速计划 / th / ThreadPool
3
0
下载
A simple C++11 Thread Pool implementation
最近提交(Master分支：3 个月前 )
9a42ec13 - 10 年前
fcc91415 - 10 年前
Logo
GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的

avatar GitCode 开源社区

centOS 8 使用dnf安装Docker

DNF是什么？CentOS 8使用YUM软件包管理器版本v4.0.4。现在，该版本使用DNF(已删除YUM)。DNF是软件包管理器。它会在Linux发行版上安装，执行更新并删除软件包。使用DNF安装Docker跳过具有损坏依赖性的程序包一个有效的解决方案是使您的CentOS 8系统使用以下--nobest命令安装最符合条件的版本：sudo dnf install docker...

avatar GitCode 开源社区

定时同步数据库表(mysql+linux+crontab)

sync.sh里面的参数需要改变，ip/username/password/database/tablesync.sh#!/bin/sh# Please change the IP and password of the data source db.# Then change the table name.filename=/home/nington/db/$(date +%Y-%m

avatar GitCode 开源社区