spring线程池ThreadPoolExecutor配置并且得到任务执行的结果

最新推荐文章于 2024-01-10 23:49:47 发布

小飞侠-2

最新推荐文章于 2024-01-10 23:49:47 发布

阅读量3.3k

点赞数

分类专栏：定时任务多线程池

定时任务多线程池专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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

ThreadPoolTask

 
package com.zuidaima.threadpool;
 
 
 
import java.io.Serializable;
 
import java.util.concurrent.Callable;
 
 
 
public class ThreadPoolTask implements Callable<String>, Serializable {
 
 
 
    private static final long serialVersionUID = 0;
 
 
 
    // 保存任务所需要的数据
 
    private Object threadPoolTaskData;
 
 
 
    private static int consumeTaskSleepTime = 2000;
 
 
 
    public ThreadPoolTask(Object tasks) {
 
        this.threadPoolTaskData = tasks;
 
    }
 
 
 
    public synchronized String call() throws Exception {
 
        // 处理一个任务，这里的处理方式太简单了，仅仅是一个打印语句
 
        System.out.println("开始执行任务：" + threadPoolTaskData);
 
        String result = "";
 
        // //便于观察，等待一段时间
 
        try {
 
            // long r = 5/0;
 
            for (int i = 0; i < 100000000; i++) {
 
 
 
            }
 
            result = "OK";
 
        } catch (Exception e) {
 
            e.printStackTrace();
 
            result = "ERROR";
 
        }
 
        threadPoolTaskData = null;
 
        return result;
 
    }
 
}

模拟客户端提交的线程

 
package com.zuidaima.threadpool;
 
 
 
import java.util.concurrent.ExecutionException;
 
import java.util.concurrent.FutureTask;
 
import java.util.concurrent.TimeUnit;
 
 
 
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
 
 
public class StartTaskThread implements Runnable {
 
 
 
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
 
    private int i;
 
 
 
    public StartTaskThread(ThreadPoolTaskExecutor threadPoolTaskExecutor, int i) {
 
        this.threadPoolTaskExecutor = threadPoolTaskExecutor;
 
        this.i = i;
 
    }
 
 
 
    @Override
 
    public synchronized void run() {
 
        String task = "task@ " + i;
 
        System.out.println("创建任务并提交到线程池中：" + task);
 
        FutureTask<String> futureTask = new FutureTask<String>(
 
                new ThreadPoolTask(task));
 
        threadPoolTaskExecutor.execute(futureTask);
 
        // 在这里可以做别的任何事情
 
        String result = null;
 
        try {
 
            // 取得结果，同时设置超时执行时间为1秒。同样可以用future.get()，不设置执行超时时间取得结果
 
            result = futureTask.get(1000, TimeUnit.MILLISECONDS);
 
        } catch (InterruptedException e) {
 
            futureTask.cancel(true);
 
        } catch (ExecutionException e) {
 
            futureTask.cancel(true);
 
        } catch (Exception e) {
 
            futureTask.cancel(true);
 
            // 超时后，进行相应处理
 
        } finally {
 
            System.out.println("task@" + i + ":result=" + result);
 
        }
 
 
 
    }
 
}

SPRING配置文件

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

测试类

 
package com.zuidaima.test;
 
 
 
import org.junit.Test;
 
import org.junit.runner.RunWith;
 
import org.springframework.beans.factory.annotation.Autowired;
 
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
 
import org.springframework.test.context.ContextConfiguration;
 
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
 
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
 
 
import com.zuidaima.threadpool.StartTaskThread;
 
 
 
@RunWith(SpringJUnit4ClassRunner.class)
 
// 指定的运行runner，并且把你所指定的Runner作为参数传递给它
 
@ContextConfiguration(locations = "classpath*:applicationContext.xml")
 
public class TestThreadPool extends AbstractJUnit4SpringContextTests {
 
 
 
    private static int produceTaskSleepTime = 10;
 
 
 
    private static int produceTaskMaxNumber = 1000;
 
 
 
    @Autowired
 
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;
 
 
 
    public ThreadPoolTaskExecutor getThreadPoolTaskExecutor() {
 
        return threadPoolTaskExecutor;
 
    }
 
 
 
    public void setThreadPoolTaskExecutor(
 
            ThreadPoolTaskExecutor threadPoolTaskExecutor) {
 
        this.threadPoolTaskExecutor = threadPoolTaskExecutor;
 
    }
 
 
 
    @Test
 
    public void testThreadPoolExecutor() {
 
        for (int i = 1; i <= produceTaskMaxNumber; i++) {
 
            try {
 
                Thread.sleep(produceTaskSleepTime);
 
            } catch (InterruptedException e1) {
 
                e1.printStackTrace();
 
            }
 
            new Thread(new StartTaskThread(threadPoolTaskExecutor, i)).start();
 
        }
 
 
 
    }
 
 
 
}

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

项目截图(基于maven构建)

运行截图：

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

原文: http://www.blogjava.net/paulwong/archive/2011/12/07/365773.html

小飞侠-2

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
spring线程池ThreadPoolExecutor配置并且得到任务执行的结果

用ThreadPoolExecutor的时候，又想知道被执行的任务的执行情况，这时就可以用FutureTask。ThreadPoolTask01package com.zuidaima.threadpool;02 03import java.io.Seri
复制链接

扫一扫