spring线程池ThreadPoolExecutor配置并且得到任务执行的结果-低调大师

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

2018-02-10 564

spring线程池ThreadPoolExecutor配置并且得到任务执行的结果http://www.bieryun.com/1170.html

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

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 
      }

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

项目截图（基于行家构建）

运行截图：

如果遇到CPU忙执行超过1秒的会返回空

微信关注我们

原文链接：https://yq.aliyun.com/articles/463886

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

java基础学习_面向对象(上)02_day07总结

========================================================================================================================================================== 涉及到的知识点有：1：成员变量和局部变量的区别(理解)2：类作为形式参数的问题？(理解)3：匿名对象(理解)4：封装(理解)5：private关键字(掌握)6：this关键字(掌握)7：构造方法(掌握) (1)作用 (2)格式 (3)构造方法的注意事项 (4)给成员变量赋值的方式有两种 (5)输出成员变量值的方式有两种 (6)标准学生案例8：类的初始化过程代码：Student s = new Student();做了哪些事情？(理解)9：面向对象的练习题(掌握) (1)标准的手机类的定义和手机测试类。 (2)Demo类中有求和方法，Test类进行测试。 (3)长方形案例。 (4)员工案例。 (5)MyMath案例(自己提供加减乘除并测试)。10：static关键字(理解) (0) ...

2018-02-10

553

如何用Python做词云？（基础篇视频教程）

只需要花10几分钟，跟着教程完整做一遍，你就能自己用Python做出词云了。《如何用Python做词云？》图文版发布于2017年6月，是我数据科学系列教程中的第一篇。目前仅简书一个平台，阅读数量就已经超过2万。我一直不断收到读者的留言和来信，询问自己动手尝试过程中遇到的问题。大部分的疑问，来自于Windows平台用户。有时候，因为一个软件包选择错误，就会遇到各种报错。错误也许是因为新版本的推出，也许是因为32位和64位平台没有正确区分……初学者如果得不到帮助，很容易迅速丧失完成的信心和兴趣。为了让大家花费更少的时间试错，更高效地掌握词云制作基本方法，我制作了对应的视频教程。视频以Windows平台上，基于Python 3.6的32位版本Anaconda为工作环境录制。注意你需要先安装好Anaconda环境。安装的方法请参考我的另一份视频教程《如何安装Python运行环境Anaconda？（视频教程）》。我把数据和附加软件包的安装文件都打包提供了给你。可以访问这个链接来下载。只需要花10几分钟，跟着教程完整做一遍，你就能自己用Python做出词云了。视频链接在这里...

2018-02-11

571

发表评论

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Nacos

Nacos /nɑ:kəʊs/ 是 Dynamic Naming and Configuration Service 的首字母简称，一个易于构建 AI Agent 应用的动态服务发现、配置管理和AI智能体管理平台。Nacos 致力于帮助您发现、配置和管理微服务及AI智能体应用。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据、流量管理。Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。