精华内容
下载资源
问答
  • 主要介绍了Spring-Boot中如何使用多线程处理任务方法,小编觉得挺不错的,现在分享给大家,也给大家做参考。一起跟随小编过来看看吧
  • 主要介绍了Spark调优多线程并行处理任务实现方式,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 启动异步线程去执行一个任务

    万次阅读 2018-01-19 21:54:48
    1.业务场景: 浦发银行...银行充值接口实现业务都是预计2小时到账,但如果需求修改发送充值接口后,立马去调用银行提供的状态查询接口,将状态查询回来时,需要启动异步线程将结果查询回来. 代码编辑如下: ...

    1.业务场景:

     浦发银行充值接口,他行卡充值不是实时将充值结果返回的,需要我们自己去手动去查。银行充值接口实现业务都是预计2小时到账,但如果需求修改发送充值接口后,立马去调用银行提供的状态查询接口,将状态查询回来时,需要启动一个异步线程将结果查询回来.

    代码编辑如下:
    <?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:p="http://www.springframework.org/schema/p"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:aop="http://www.springframework.org/schema/aop" 
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
               http://www.springframework.org/schema/aop   
               http://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
               http://www.springframework.org/schema/tx  
               http://www.springframework.org/schema/tx/spring-tx-3.2.xsd  
               http://www.springframework.org/schema/context  
               http://www.springframework.org/schema/context/spring-context-3.2.xsd"
        default-autowire="byName" default-lazy-init="false">
    
        <!-- 使用spring提供的线程池 -->
        <bean id="executePool" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
            <!-- 线程池维护线程的最小数量 -->
            <property name="corePoolSize" value="1"></property>
            <!-- 线程池维护线程所允许的空闲时间 -->
            <property name="maxPoolSize" value="5"></property>
            <!-- 线程池所使用的最大数量 -->
            <property name="keepAliveSeconds" value="30000" />
            <!-- 线程池所使用的缓冲队列 -->
            <property name="queueCapacity" value="1000" />
        </bean>
    
        <bean id="asyExecuteService" class="com.adai.asy.service.imp.AsyExecuteServiceImp" destroy-method="destory">
            <property name="executePool"  ref="executePool" />
        </bean>
        
        <context:annotation-config/>
        <context:component-scan base-package="com.adai"/>
    </beans>
    
    package com.adai.asy.service;
    
    import java.util.Map;
    /**
     * 异步服务接口
     * @author v-chenk25
     * @since 2018-01-19 21:35
     *
     */
    public interface AsyExecuteService {
    	/**
    	 * 异步服务
    	 * @param taskId  服务id
    	 * @param sendMap 请求参数
    	 */
    	public void execute(String taskId , Map<String,Object> sendMap);
    }
    
    package com.adai.asy.service;
    
    import java.util.Map;
    
    /**
     * 异步接口
     * @author v-chenk25
     * @since 2018-01-19 21:35
     *
     */
    public interface AsyService {
    	/**
    	 * 异步交易接口
    	 * @param sendMap 请求参数
    	 */
    	public void execute(Map<String,Object> sendMap) ;
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Date;
    import java.util.Map;
    
    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
    
    import com.adai.asy.service.AsyExecuteService;
    import com.adai.asy.service.AsyService;
    import com.adai.constant.Dict;
    import com.adai.util.Utils;
    /**
     * 异步服务实现类:这里需要注入线程池启动一个线程去执行任务
     * @author v-chenk25
     * @since 2018-01-19 21:35
     */
    public  class AsyExecuteServiceImp implements AsyExecuteService , ApplicationContextAware{
    	private ApplicationContext context ;
    	private ThreadPoolTaskExecutor executePool ;
    	public void execute(String taskId, final Map<String, Object> sendMap) {
    		sendMap.put(Dict.TASKID, taskId) ;
    		final AsyService asyService = (AsyService) this.context.getBean(taskId) ;
    		this.executePool.execute(new Runnable() {
    			public void run() {
    				asyService.execute(sendMap);
    			}
    		});
    		
    		
    	}
    	
    	public Map<String,Object> prepareReq(Map<String,Object> sendMap){
    		sendMap.put(Dict.ORDERID, Utils.getCurrentFormat(new Date(), Dict.YNRH)) ;
    		return sendMap;
    	}
    	
    	public void destory() {
    		if(this.executePool != null) {
    			this.executePool.shutdown();
    		}
    	}
    	
    	public void setApplicationContext(ApplicationContext context) throws BeansException {
    		this.context = context ;
    	}
    	public void setExecutePool(ThreadPoolTaskExecutor executePool) {
    		this.executePool = executePool;
    	}
    	
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    import com.adai.asy.service.AsyService;
    import com.adai.constant.Dict;
    /**
     * 异步服务接口实现类
     * 这里主要时为了打印每一个任务需要执行的时间,正真执行业务逻辑的方法是executeInnert
     * @author v-chenk25
     *
     */
    public abstract class AsyServiceImp implements AsyService{
    	private Log log = LogFactory.getLog(AsyServiceImp.class) ;
    	public void execute(Map<String,Object> sendMap) {
    		long start = System.currentTimeMillis();
    		log.info("异步线程开始执行:"+sendMap.get(Dict.TASKID)+"任务");
    		executeInnert(sendMap) ;
    		long end = System.currentTimeMillis();
    		log.info("异步线程执行结束,任务执行时间为:"+(end-start));
    	}
    	
    	/** 真正执行业务逻辑 **/
    	public abstract void executeInnert(Map<String,Object> sendMap);
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.springframework.stereotype.Service;
    
    import com.adai.asy.service.AsyService;
    /**
     * 需要异步执行任务的具体实现类
     * @author v-chenk25
     *
     */
    @Service("myTaskAsyService1")
    public class MyTaskAsyServiceImp extends AsyServiceImp implements AsyService  {
    
    	@Override
    	public void executeInnert(Map<String, Object> sendMap) {
    		//做自己的业务逻辑处理 , 比如发银行的接口,调用dubbo服务
    		System.out.println(this.getClass().getName());
    		System.out.println(sendMap);
    	}
    
    
    }
    
    package com.adai.constant;
    /**
     * 常量字典
     * @author v-chenk25
     *
     */
    public class Dict {
    	/**交易流水号**/
    	public static final String ORDERID = "OrderId" ;
    	/** 日期格式 **/
    	public static final String YND = "yyyyMMdd" ;
    	/**时间戳格式**/
    	public static final String YNRH = "yyyyMMdd HH:mm:ss sss" ;
    	/**时间格式**/
    	public static final String HOUR = "HH:mm:ss" ;
    	/**交易id**/
    	public static final String TASKID = "taskId" ;
    	
    }
    
    package com.adai.util;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    /**
     * 工具类
     * @author v-chenk25
     *
     */
    public class Utils {
    	
    	/**当前日期指定格式字符串**/
    	public static String getCurrentFormat(Date date ,String format) {
    		return new SimpleDateFormat(format).format(date);
    	}
    }
    
    package com.adai.asy.service.imp;
    
    import java.util.Map;
    
    import org.springframework.stereotype.Service;
    
    import com.adai.asy.service.AsyService;
    /**
     * 需要异步执行任务的具体实现类
     * @author v-chenk25
     *
     */
    @Service("myTaskAsyService2")
    public class MyTaskAsyServiceImp2 extends AsyServiceImp implements AsyService  {
    
    	@Override
    	public void executeInnert(Map<String, Object> sendMap) {
    		//做自己的业务逻辑处理
    		System.out.println(this.getClass().getName());
    		System.out.println(sendMap);
    	}
    
    
    }
    
    package com.adai;
    
    import java.util.HashMap;
    import java.util.Map;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    import com.adai.asy.service.AsyExecuteService;
    
    public class TestAsy {
    	public static void main(String[] args) {
    		ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(new String[] {"classpath:spring-activemq.xml"}) ;
    		context.start();
    		AsyExecuteService asyService = (AsyExecuteService) context.getBean("asyExecuteService") ;
    		for(int i=1 ; i<10 ;i++) {
    			Map<String,Object> sendMap = new HashMap<String,Object>() ;
    			sendMap.put(i+"", i) ;
    			asyService.execute("myTaskAsyService"+1, sendMap);
    		}
    	}
    }
    
    总结:设计思路为:使用一个线程池开启一个线程去执行一个任务,任务id就是spring bean的名字,通ApplicationContextAware 来获取spring容器的bean,然后调用execute方法执行具体的业务逻辑。为了扩展,所以要求需要异步执行的类需要现实统一的接口,也就是AsyService接口。
    展开全文
  • JAVA多线程10个线程处理1000数据

    万次阅读 2018-11-06 11:02:14
    int threadNum = 10; ExecutorService executorService = Executors.newFixedThreadPool(threadNum); CountDownLatch countDownLatch = new CountDownLatch(threadNum); int perSize = idList.size() / ...
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class MultiThreadTest {
    
        public static void main(String[] args) throws Exception {
            List<Integer> idList = new ArrayList<>();
            for (int i = 0; i < 1000; i++) {
                idList.add(i);
            }
            int threadNum = 10;
            ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
            CountDownLatch countDownLatch = new CountDownLatch(threadNum);
            int perSize = idList.size() / threadNum;
            for (int i = 0; i < threadNum; i++) {
                MultiThread thread = new MultiThread();
                thread.setIdList(idList.subList(i * perSize, (i + 1) * perSize));
                thread.setCountDownLatch(countDownLatch);
                executorService.submit(thread);
            }
            countDownLatch.await();
            executorService.shutdown();
        }
    }
    
    class MultiThread extends Thread {
        private List<Integer> idList;
    
        private CountDownLatch countDownLatch;
    
        public void setIdList(List<Integer> idList) {
            this.idList = idList;
        }
    
        public void setCountDownLatch(CountDownLatch countDownLatch) {
            this.countDownLatch = countDownLatch;
        }
    
        @Override
        public void run() {
            try {
                Thread.sleep(1000);
                System.out.println(this.idList);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (countDownLatch != null) {
                    countDownLatch.countDown();
                }
            }
        }
    }

     

    展开全文
  • Java多线程之运行多个任务处理所有结果

    万次阅读 热门讨论 2018-08-23 23:13:47
    执行器框架给我们提供了一方法,让我们可以发送给执行器一个任务列表,并等待任务列表中的所有任务执行完毕。然后它将返回一任务列表对应的Future列表。 package com.primer.demo.util; import lombok....

    执行器框架给我们提供了一个方法,让我们可以发送给执行器一个任务列表,并等待任务列表中的所有任务执行完毕。然后它将返回一个与任务列表对应的Future列表。

    package com.primer.demo.util;
    
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.*;
    
    @Slf4j
    public class ThreadPool {
    
        private static ExecutorService executorService = new ThreadPoolExecutor(100, 500, 1, TimeUnit.SECONDS, new LinkedBlockingDeque());
    
        public static <T> List<T> addTask(List<Callable<T>> tasks) {
            List<Future<T>> futureList = null;
            List<T> results = null;
            try {
                futureList = executorService.invokeAll(tasks);
                results = new ArrayList<>();
                for (Future<T> future : futureList) {
                    results.add(future.get());
                }
            } catch (InterruptedException | ExecutionException e) {
                e.printStackTrace();
            }
            return results;
        }
    }

    创建多个任务并显示结果:

    package com.primer.demo.service;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.Callable;
    
    import org.junit.FixMethodOrder;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.MethodSorters;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.annotation.Rollback;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import com.primer.demo.util.ThreadPool;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest
    @FixMethodOrder(MethodSorters.NAME_ASCENDING)
    @Rollback(false)
    public class Demo2ServiceTest {
    
        @Test
        public void test(){
            List<Callable<String>> callables = new ArrayList<>();
            for(int i=0;i<10;i++){
                callables.add(()-> Math.random()+"");
            }
            List<String> res = ThreadPool.addTask(callables);
            System.out.println("**********************");
            for(String str : res){
                System.out.println(str);
            }
        }
    }

    完整代码请参考:https://github.com/465919283/demo

    展开全文
  • 该接口就是用来配置异步线程池的接口,它有两方法,getAsyncExecutor和getAsyncUncaughtExceptionHandler,第一方法是获取一线程池,第二方法是用来处理异步线程中发生的异常。它的源码如下所示: package ...

    一、定义线程池和开启异步可用

    Spring中存在一个接口AsyncConfigurer接口,该接口就是用来配置异步线程池的接口,它有两个方法,getAsyncExecutor和getAsyncUncaughtExceptionHandler,第一个方法是获取一个线程池,第二个方法是用来处理异步线程中发生的异常。它的源码如下所示:

    package org.springframework.scheduling.annotation;
    
    import java.util.concurrent.Executor;
    import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
    import org.springframework.lang.Nullable;
    
    public interface AsyncConfigurer {
    
    	// 获取线程池
    	@Nullable
    	default Executor getAsyncExecutor() {
    		return null;
    	}
    
    	// 异步异常处理器
    	@Nullable
    	default AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
    		return null;
    	}
    }
    
    

    一般写法:

    实现上面异步接口
    @Configuration
    @EnableAsync
    @Slf4j
    public class AsyncConfig implements AsyncConfigurer {
    
        @Override
        public Executor getAsyncExecutor() {
            // 自定义线程池
            ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
            // 核心线程数
            taskExecutor.setCorePoolSize(10);
            // 最大线程数
            taskExecutor.setMaxPoolSize(30);
            // 线程队列最大线程数
            taskExecutor.setQueueCapacity(2000);
            // 初始化线程池
            taskExecutor.initialize();
            return taskExecutor;
        }
    
        @Override
        public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
            return (ex, method, params) -> {
                log.error("Error Occurs in async method:{}", ex.getMessage());
            };
        }
    }
    
    

    这时我们在config类上使用了@EnableAsync注解,当在spring中注入改bean时就会开启异步任务

    测试异步可用机制

    service层

    public interface AsyncService {
    
        /**
         * 模拟生成报表的异步方法
         */
        void testAsync();
    
    }
    
    

    实现层

    import cn.itlemon.springboot.async.service.AsyncService;
    import org.springframework.scheduling.annotation.Async;
    import org.springframework.scheduling.annotation.AsyncResult;
    import org.springframework.stereotype.Service;
    import java.util.concurrent.Future;
    @Service
    public class AsyncServiceImpl implements AsyncService {
    
        @Override
        @Async("getAsyncExecutor")
        public void testAsync() {
            // 打印线程名称
            System.out.println("线程名称:【" + Thread.currentThread().getName() + "】");
        }
    }
    
    
    展开全文
  • SpringBoot多线程任务处理

    千次阅读 2019-03-01 08:56:47
    看到这标题,相信不少人会感到疑惑,回忆你们自己的场景会发现,在Spring的项目中很少有使用多线程处理任务的,没错,大多数时候我们都是使用Spring MVC开发的web项目,默认的Controller,Service,Dao组件的作用...
  • ExecutorService 10个线程处理for循环

    千次阅读 2019-05-17 16:23:02
    线程处理需要20分钟, 使用10个线程,2分钟处理完毕 多线程处理过程概述: 利用ExecutorService创建线程池 public class A{ private static final int TOTAL_THREADS = 10;//线程数 pub...
  • java 多任务通过多线程处理demo

    千次阅读 2018-06-29 15:57:06
    通过线程可以让多核机器同时完成多条复杂任务,理论来说可以减少将近一半的程序运行时间。通过主线程触发子线程启动,之后主线程等待子线程执行结束的通知,如果所有子线程都完成之后主线程才会继续走下去。 版本...
  • java开启新线程的三种方法: 方法1:继承Thread类 ...4):在main方法(线程)中,创建一线程对象并启动线程。 (1)创建线程类对象: A类 a = new A类(); (2)调用线程对象的start方法: a.start();...
  • QT (启动个线程)

    万次阅读 2018-12-01 17:06:47
    启动个线程的步骤: (1) 创建一自己的线程类继承QT中的QThread类 创建线程类WorkThread; (2) 在自己的WorkThreak类中重新实现run()函数, 该函数是一死循环, 主要是完成自己需要的功能代码 (3) 使用自己的类...
  • springboot多线程定时任务

    千次阅读 2018-09-04 22:42:43
    我们经常会遇到定时任务,在某个特定的时间点,程序会自主触发去执行一些机械重复的工作,这样就可以将人力与精力彻底的解放出来了。 在最近的工作中,先是在后台报表工程中用到了springboot自带的定时器标签@...
  • 首先需要知道: 1,这里所说的广播是静态广播 ...所以建议在onReceive中启动服务(再在服务中开线程任务)做长时间任务。这样程序进程为后台进程(没有使用startForeground)系统就不会任意时刻回收此进程
  • Scheduled开启多线程,同时执行多定时任务.
  • SpringBoot开启多线程定时任务

    千次阅读 2020-06-05 11:44:00
    1.springBoot默认的定时任务为串行方式,即所有任务都只有一个线程在执行 代码示例: springBoot启动类 @SpringBootApplication @EnableScheduling /**开启定时任务*/ public class Application extends ...
  • 最近转到银行工作,在做最核心的财务账务部分,对我来说是一比较新的东西,工作也已经四年有余,接触一些新的东西,也是不错,每天也累得像狗...,不说了。/捂脸 接下来说一种非常实用的多线程操作模式,此方式能够...
  • 定时任务使用多线程注意事项

    千次阅读 2021-03-22 18:08:17
    在定时任务中为了加快处理速度,一般都会使用多线程处理业务。需要注意一下事项:1. 定时任务是否允许上一定时任务未结束,下一定时任务可以启动,通过Scheduled中的配置在决定。2. 主线程已经关闭,线程池中的...
  • 线程:多线程则指的是在单个程序中可以同时运行多不同的线程执行不同的任务.线程是程序内的顺序控制流,只能使用分配给程序的资源和环境。多线程编程的目的,就是"最大限度地利用CPU资源",当某一线程...
  • 在python程序中,我们往往会遇到需要在一脚本里面,同时执行多项任务的需求,那么此时,我们可以开启一个线程去执行。 如下面,我需要开启一读取redis白名单线程任务。 每一分钟跟新一次用户白名单。 import ...
  • 定时任务下的多线程任务

    千次阅读 2018-03-21 17:45:55
    webApplicationContext ServletContext 是java中的Servlet工程的上下文对象 webApplicationContext是Spring框架中定义的继承了ServletContext上下文对象的web上下文对象Spring框架定义了一ContextLoad...
  • Springboot 项目启动另起线程

    千次阅读 2020-08-03 17:19:24
    有时候我们需要在项目启动创建一个线程去定时处理一些数据之类的,当然也可以用类似xxl-job的定时任务处理,这里我们使用项目启动的同时开启一个线程的方式 实现 @Component @Slf4j public class ClearThread ...
  • 先说结论:main方法启动后,jvm会开启多守护线程,但main方法中的代码是被单线程执行的。 上代码: 下面这段代码通过java提供的线程管理类ThreadMXBean中的dumpAllThreads方法返回所有活动线程线程信息,并打印...
  • 线程开启定时任务

    千次阅读 2017-09-21 14:25:37
    Web应用启动时,后台自动启动个线程   (2014-05-01 11:05:45) 转载▼ 标签:  java   listener   servlet   web应用启动   cron 分类: Java (1)...
  • 线程、进程、多线程、多进程 和 多任务 小结

    千次阅读 多人点赞 2019-04-20 11:59:56
    目录 1 进程 2 线程 3 多进程 4 多线程 5 线程与进程的关系 ...6 线程和进程的区别 ...8 线程的优缺点 ...8.1 线程的优点 ...8.2 线程的缺点 ...9 多线程的优缺点 ...9.1 多线程的优点 ...9.2 多线程的缺点 ...8 多任务(多进...
  • 线程任务管理器的目的是为了在系统资源可用时自动运行线程任务或同时执行多个线程任务。Android API提供了ThreadPoolExecutor类,它管理了一线程池,当线程池中的某个线程可用时它会从任务队列中取出一个任务来...
  • JAVA多线程执行任务

    千次阅读 2019-01-26 23:14:00
    因此要求队员要用多线程处理。那么主线程要等待所有子线程任务执行完毕主要有以下几种方法: 方法1:使用CountDownLatch 这类是在JDK1.5就已经提供了,它允许一或多线程一直等待,直到其他线程的操作执行完...
  • web应用启动时就执行特定处理  * @author liuyajun  *  */ @Component public class StartupListener implements ApplicationContextAware{   @Override   ...
  • java多线程分批执行任务demo

    千次阅读 2020-04-28 15:01:07
    10个任务完成后,不管任务成功或者失败,线程池回收10个线程继续完成剩下10个任务。 实际应用:当我们批量的需求比如启动1000节点,启动节点的时间大概是3s,我们肯定不会去并行执行1000次启动,肯定是利用...
  • MFC启动线程的三种方法

    千次阅读 2019-03-11 16:40:39
    转载于:... 第一种AfxBeginThread() 用AfxBeginThread()函数来创建一线程来执行任务,工作者线程的AfxBeginThread的原型如下: CWinThread* AfxBeginThread(AFX_THREADPROC pfnThreadProc, ...
  • Spring-Boot中如何使用多线程处理任务

    万次阅读 2016-08-25 19:22:37
    看到这标题,相信不少人会感到疑惑,回忆你们自己的场景会发现,在Spring的项目中很少有使用多线程处理任务的,没错,大多数时候我们都是使用Spring MVC开发的web项目,默认的Controller,Service,Dao组件的作用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 309,066
精华内容 123,626
关键字:

启动10个线程处理任务