精华内容
下载资源
问答
  • java中实现多线程之实现runnable接口 1.处理业务代码 //根据传参打印对应的名字 private void printName(String name) throws Exception{ System.out.println(name); } 2.创建内部类实现Runnable接口 private ...

    java中实现多线程之实现runnable接口

    1.处理业务代码

    //根据传参打印对应的名字
         private void printName(String name) throws Exception{
             System.out.println(name);
         }
    

    2.创建内部类实现Runnable接口

    private class PrintName implements Runnable{
            private String name;
    
            public PrintName(String name){
                this.name = name;
            }
    
            //Runnable接口中的抽象方法
            @Override
            public void run(){
                try {
                    printName(name);
                }catch (Exception e){
                    System.out.println(e);
                }
    
            }
        }
    
    1. 创建线程对象并执行线程
    private void createThead() throws Exception {
             String name = "hello world";
             Thread thread = new Thread(new PrintName(name));
             thread.start();
         }
    

    现在附上全部代码:

    package com.ieou.demo.controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("/")
    public class Demo1Controller {
    
    
        /**  java 多线程 异步实现demo           */
    
        //第一步 处理业务代码
        //根据传参打印对应的名字
        private void printName(String name) throws Exception{
            System.out.println(name);
        }
    
        //创建内部类实现Runnable接口
        private class PrintName implements Runnable{
            private String name;
    
            public PrintName(String name){
                this.name = name;
            }
    
            //Runnable接口中的抽象方法
            @Override
            public void run(){
                try {
                    printName(name);
                }catch (Exception e){
                    System.out.println(e);
                }
    
            }
        }
    
        //第三部 创建线程对象
        private void createThead() throws Exception {
            String name = "hello world";
            Thread thread = new Thread(new PrintName(name));
            thread.start();
        }
    
        @GetMapping("/name")
        public String findName() throws Exception{
            System.out.println("name1");
            createThead();
            System.out.println("name3");
            return "1";
        }
    
    展开全文
  • 下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。 import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.transaction.PlatformTransactionManager; import org...

    前言:项目中在保证数据一致性的前提下还想提高执行效率,有什么好办法么?使用多线程肯定是首先想到的,但多线程之间的事务怎么保持一致呢?下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.TransactionDefinition;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.transaction.support.DefaultTransactionDefinition;
    
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.List;
    import java.util.concurrent.Callable;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.Future;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.atomic.AtomicReference;
    
    /**
     * 多线程异步处理时的事务管理
     * 1.addFunction 添加要异步执行的方法
     * 2.execute方法中,使用全局的计数器和异常标记字段,统计个异步线程执行的结果
     *      当所有异步线程执行完之后,根据异常标记字段判断是回滚还是提交事务。
     */
    public class MultiThreadTransactionComponent {
        Logger logger= LoggerFactory.getLogger(this.getClass());
    
        private PlatformTransactionManager platformTransactionManager;
        private ThreadPoolExecutor threadPoolExecutor;
    
        private List<Callable> supplierList=new ArrayList();
        // 创建执行计数器
        private CountDownLatch countDownLatch;
        // 是否存在异常
        AtomicReference<Boolean> isError = new AtomicReference<>(false);
    
        /**
         * @param transactionManager  如果为null  就不启用事务
         * @param threadPoolExecutor
         */
        public MultiThreadTransactionComponent(PlatformTransactionManager transactionManager,ThreadPoolExecutor threadPoolExecutor){
            this.platformTransactionManager=transactionManager;
            this.threadPoolExecutor=threadPoolExecutor;
        }
    
        /**
         * 添加要异步执行的方法程序
         * @param supplier
         */
        public void addFunction(Callable supplier){
            supplierList.add(supplier);
        }
    
        public List execute(){
            countDownLatch=new CountDownLatch(supplierList.size());
            logger.info("【多线程事务】开始...");
            List<Future> futureList=new ArrayList<>();
            for(Callable supplier:supplierList){
                Future submit = this.threadPoolExecutor.submit(new TransactionRunnable(platformTransactionManager, supplier));
                futureList.add(submit);
            }
            List resultList=new ArrayList();
            try {
                countDownLatch.await();
                //获取线程处理结果
                for(Future future:futureList){
                    Object result = future.get();
                    if(result instanceof Collection){
                        resultList.addAll((Collection) result);
                    }else {
                        resultList.add(result);
                    }
                }
                if(isError.get()) {
                    logger.error("【多线程事务】多线程执行失败");
                    // 主线程抛出自定义的异常
                    throw new RuntimeException("多线程执行失败");
                }
                logger.info("【多线程事务】多线程执行完成");
            } catch (Exception e) {
                logger.error("多线程执行失败");
                // 主线程抛出自定义的异常
                throw new RuntimeException("多线程执行失败"+e.getMessage());
            }
            return resultList;
        }
    
    
        class TransactionRunnable implements Callable {
    
            private PlatformTransactionManager platformTransactionManager;
            private Callable supplier;
    
            public TransactionRunnable(PlatformTransactionManager platformTransactionManager, Callable supplier) {
                this.platformTransactionManager=platformTransactionManager;
                this.supplier=supplier;
            }
    
            @Override
            public Object call() {
                TransactionStatus transaction=null;
                if(platformTransactionManager!=null){
                    DefaultTransactionDefinition def = new DefaultTransactionDefinition();
                    def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                    transaction = this.platformTransactionManager.getTransaction(def);
                }
                Object result=null;
                try {
                    result= this.supplier.call();
                } catch (Exception e) {
                    //设置错误标记
                    isError.set(true);
                    logger.error("【多线程事务】执行失败{}",e.getMessage());
                }
                countDownLatch.countDown();
                try{
                    countDownLatch.await();
                    if(platformTransactionManager!=null) {
                        if (isError.get()) {
    //                      logger.info("【多线程事务-子线程】事务回滚");
                            platformTransactionManager.rollback(transaction);
                        } else {
    //                    logger.info("【多线程事务-子线程】事务提交");
                            platformTransactionManager.commit(transaction);
                        }
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                return result;
            }
        }
    
    }
    

    使用示例:

        @Autowired
        PlatformTransactionManager platformTransactionManager;
        @Autowired
        private ThreadPoolExecutor threadPoolExecutor;
        @Test
        public void testTransaction(){
            List<Integer> result=new ArrayList<>();
            MultiThreadTransactionComponent mttc = new MultiThreadTransactionComponent(platformTransactionManager,threadPoolExecutor);
            for(int k=0;k<10;k++){
                int i = RandomUtils.nextInt(0, 5);
                int y= RandomUtils.nextInt(1,5);
                //添加要执行的业务代码
                mttc.addFunction(()->{
                    System.out.println("当前线程:" + Thread.currentThread().getName());
                    System.out.println(i%y);  //除数为0时 执行失败
                    return i%y;
                });
            }
            result= mttc.execute();
            System.out.println(result.stream().mapToInt(Integer::intValue).sum());
        }
    
    展开全文
  • 下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。 具体思路打个比方来说明一下: 代码噼里啪啦的一顿敲,终于把需求实现了。 现在想休息几分钟,但公司比较抠,只能让你休息三分钟,三分钟后...

    分布式事务介绍:https://zhuanlan.zhihu.com/p/183753774

    前言:项目中在保证数据一致性的前提下还想提高执行效率,有什么好办法么?使用多线程肯定是首先想到的,但多线程之间的事务怎么保持一致呢?下面的代码就是在单个项目中使用多线程异步处理时的事务管理的方法。

    
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.TransactionDefinition;
    import org.springframework.transaction.TransactionStatus;
    import org.springframework.transaction.support.DefaultTransactionDefinition;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ThreadPoolExecutor;
    import java.util.concurrent.atomic.AtomicReference;
    import java.util.function.Supplier;
    
    /**
     * 多线程异步处理时的事务管理
     * 1.addFunction 添加要异步执行的方法
     * 2.execute方法中,使用全局的计数器和异常标记字段,统计个异步线程执行的结果
     *      当所有异步线程执行完之后,根据异常标记字段判断是回滚还是提交事务。
     */
    public class MultiThreadTransactionComponent {
        Logger logger= LoggerFactory.getLogger(this.getClass());
    
        private PlatformTransactionManager platformTransactionManager;
        private ThreadPoolExecutor threadPoolExecutor;
    
        private List<Supplier> supplierList=new ArrayList();
        // 创建执行计数器
        private CountDownLatch countDownLatch;
        // 是否存在异常
        AtomicReference<Boolean> isError = new AtomicReference<>(false);
    
        public MultiThreadTransactionComponent(PlatformTransactionManager transactionManager,ThreadPoolExecutor threadPoolExecutor){
            this.platformTransactionManager=transactionManager;
            this.threadPoolExecutor=threadPoolExecutor;
        }
    
        /**
         * 添加要异步执行的方法程序
         * @param supplier
         */
        public void addFunction(Supplier supplier){
            supplierList.add(supplier);
        }
    
        public void execute(){
            countDownLatch=new CountDownLatch(supplierList.size());
            logger.info("【多线程事务】开始...");
            for(Supplier supplier:supplierList){
                this.threadPoolExecutor.submit(new TransactionRunnable(platformTransactionManager,supplier));
            }
            try {
                countDownLatch.await();
                if(isError.get()) {
                    logger.error("【多线程事务】多线程执行失败,事务已回滚");
                    // 主线程抛出自定义的异常
                    throw new RuntimeException("多线程执行失败");
                }
                logger.info("【多线程事务】多线程执行完成,事务已提交");
            } catch (InterruptedException e) {
                logger.error("多线程执行失败");
                // 主线程抛出自定义的异常
                throw new RuntimeException("多线程执行失败"+e.getMessage());
            }
        }
    
    
        class TransactionRunnable implements Runnable{
    
            private PlatformTransactionManager platformTransactionManager;
            private Supplier supplier;
    
            public TransactionRunnable(PlatformTransactionManager platformTransactionManager, Supplier supplier) {
                this.platformTransactionManager=platformTransactionManager;
                this.supplier=supplier;
            }
    
            @Override
            public void run() {
                DefaultTransactionDefinition def = new DefaultTransactionDefinition();
                def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                TransactionStatus transaction = this.platformTransactionManager.getTransaction(def);
                try {
                    this.supplier.get();
                } catch (Exception e) {
                    //设置错误标记
                    isError.set(true);
                    logger.error("【多线程事务】执行失败{}",e.getMessage());
                }
                countDownLatch.countDown();
                try{
                    countDownLatch.await();
                    if(isError.get()){
    //                    logger.info("【多线程事务-子线程】事务回滚");
                        //事务回滚
                        platformTransactionManager.rollback(transaction);
                    }else {
    //                    logger.info("【多线程事务-子线程】事务提交");
                        //事务提交
                        platformTransactionManager.commit(transaction);
                    }
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        }
    
    }
    

    使用示例:

        @Autowired
        PlatformTransactionManager platformTransactionManager;
        @Autowired
        private ThreadPoolExecutor threadPoolExecutor;
        @Test
        public void testTransaction(){
            MultiThreadTransactionComponent mttc = new MultiThreadTransactionComponent(platformTransactionManager,threadPoolExecutor);
            for(int k=0;k<10;k++){
                int i = RandomUtils.nextInt(0, 5);
                int y=RandomUtils.nextInt(0,5);
                //添加要执行的业务代码
                mttc.addFunction(()->{
                    System.out.println("当前线程:" + Thread.currentThread().getName());
                    System.out.println(i%y);  //除数为0时 执行失败
                    MarketGeomUpLog marketGeomUpLog=new MarketGeomUpLog();
                    marketGeomUpLog.setContent(i+"--"+y);
                    marketGeomUpLogMapper.addLog(marketGeomUpLog);
                    return 0;
                });
            }
            mttc.execute();
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    
    展开全文
  • 需求:用@schedule标签进行定时处理逻辑,由于业务处理速度慢,需要每次执行逻辑放在不同的线程里异步执行springboot集成多线程异步,直接上配置:/*** 线程池异步配置*/@Configuration@EnableAsyncpublic class ...

    需求:用@schedule标签进行定时处理逻辑,由于业务处理速度慢,需要每次执行逻辑放在不同的线程里异步执行

    springboot集成多线程异步,直接上配置:

    /**

    * 线程池异步配置

    */

    @Configuration

    @EnableAsync

    public class ThreadExecutorConfig

    implements AsyncConfigurer {

    @Override

    public Executor getAsyncExecutor() {

    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();

    // 设置核心线程数

    executor.setCorePoolSize(5);

    // 设置最大线程数

    executor.setMaxPoolSize(7);

    // 设置队列容量

    executor.setQueueCapacity(20);

    // 设置线程活跃时间(秒)

    executor.setKeepAliveSeconds(60);

    // 设置默认线程名称

    executor.setThreadNamePrefix("PASCAL-");

    // 设置拒绝策略

    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

    // 等待所有任务结束后再关闭线程池

    executor.setWaitForTasksToCompleteOnShutdown(true);

    executor.initialize();

    return executor;

    }

    @Override

    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {

    return new MyAsyncUncaughtExceptionHandler();

    }

    }

    下面的是对多线程异步的时候报出的异常处理方法,可以自定义一个处理多线程异常类来实现自身的业务逻辑.

    import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;

    import java.lang.reflect.Method;

    public class MyAsyncUncaughtExceptionHandler implements

    AsyncUncaughtExceptionHandler {

    @Override

    public void handleUncaughtException(Throwable ex,

    Method method, Object... params) {

    // handle exception

    }

    }

    启动类上要记得添加异步和开启定时器的标签

    @SpringBootApplication

    @EnableScheduling

    @Async

    public class MultithreadingApplication {

    public static void main(String[] args) {

    SpringApplication.run(MultithreadingApplication.class, args);

    }

    }

    业务逻辑方法:

    @Async

    @Scheduled(initialDelay=1000,fixedDelay = 5000)

    public void test(){

    SimpleDateFormat format=new SimpleDateFormat("HH:mm:ss");

    try {

    logger.info("当前线程为:"+Thread.currentThread().getName()+",方法开始时间为:"+format.format(new Date()));

    Thread.sleep(10000);

    logger.info("当前线程为:"+Thread.currentThread().getName()+",方法结束时间为:"+format.format(new Date()));

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    对于@Schedule注解的使用方法:

    点进去可以看到有几个可选参数:

    fixedDelay:控制方法执行的间隔时间,是以上一次方法执行完开始算起,如上一次方法执行阻塞住了,那么直到上一次执行完,并间隔给定的时间后,执行下一次

    fixedRate:是按照一定的速率执行,是从上一次方法执行开始的时间算起,如果上一次方法阻塞住了,下一次也是不会执行,但是在阻塞这段时间内累计应该执行的次数,当不再阻塞时,一下子把这些全部执行掉,而后再按照固定速率继续执行。

    initialDelay:如: @Scheduled(initialDelay = 10000,fixedRate = 15000

    这个定时器就是在上一个的基础上加了一个initialDelay = 10000 意思就是在容器启动后,延迟10秒后再执行一次定时器,以后每15秒再执行一次该定时器.

    cron表达式可以定制化执行任务,但是执行的方式是与fixedDelay相近的,也是会按照上一次方法结束时间开始算起。

    这里可以根据自身的业务需求,看到底选择哪一个更适合,这里cron表达式就不再多言,可以结合自身应用场景来定

    这样,需求就实现了

    测试结果:

    20-07-07 11:12:40.436 INFO 32360 --- [ main] o.s.b.w.embedded.tomcat.TomcatWebServer : Tomcat started on port(s): 8081 (http) with context path ''

    2020-07-07 11:12:40.444 INFO 32360 --- [ main] c.e.m.MultithreadingApplication : Started MultithreadingApplication in 1.223 seconds (JVM running for 1.739)

    2020-07-07 11:12:41.445 INFO 32360 --- [ scheduling-1] o.s.s.concurrent.ThreadPoolTaskExecutor : Initializing ExecutorService

    2020-07-07 11:12:41.452 INFO 32360 --- [ PASCAL-1] c.e.multithreading.service.TestService : 当前线程为:PASCAL-1,方法开始时间为:11:12:41

    2020-07-07 11:12:46.448 INFO 32360 --- [ PASCAL-2] c.e.multithreading.service.TestService : 当前线程为:PASCAL-2,方法开始时间为:11:12:46

    2020-07-07 11:12:51.450 INFO 32360 --- [ PASCAL-3] c.e.multithreading.service.TestService : 当前线程为:PASCAL-3,方法开始时间为:11:12:51

    2020-07-07 11:12:51.453 INFO 32360 --- [ PASCAL-1] c.e.multithreading.service.TestService : 当前线程为:PASCAL-1,方法结束时间为:11:12:51

    2020-07-07 11:12:56.449 INFO 32360 --- [ PASCAL-2] c.e.multithreading.service.TestService : 当前线程为:PASCAL-2,方法结束时间为:11:12:56

    2020-07-07 11:12:56.450 INFO 32360 --- [ PASCAL-4] c.e.multithreading.service.TestService : 当前线程为:PASCAL-4,方法开始时间为:11:12:56

    2020-07-07 11:13:01.450 INFO 32360 --- [ PASCAL-3] c.e.multithreading.service.TestService : 当前线程为:PASCAL-3,方法结束时间为:11:13:01

    2020-07-07 11:13:01.452 INFO 32360 --- [ PASCAL-5] c.e.multithreading.service.TestService : 当前线程为:PASCAL-5,方法开始时间为:11:13:01

    2020-07-07 11:13:06.451 INFO 32360 --- [ PASCAL-4] c.e.multithreading.service.TestService : 当前线程为:PASCAL-4,方法结束时间为:11:13:06

    2020-07-07 11:13:06.453 INFO 32360 --- [ PASCAL-1] c.e.multithreading.service.TestService : 当前线程为:PASCAL-1,方法开始时间为:11:13:06

    2020-07-07 11:13:11.453 INFO 32360 --- [ PASCAL-5] c.e.multithreading.service.TestService : 当前线程为:PASCAL-5,方法结束时间为:11:13:11

    2020-07-07 11:13:11.455 INFO 32360 --- [ PASCAL-2] c.e.multithreading.service.TestService : 当前线程为:PASCAL-2,方法开始时间为:11:13:11

    2020-07-07 11:13:16.453 INFO 32360 --- [ PASCAL-1] c.e.multithreading.service.TestService : 当前线程为:PASCAL-1,方法结束时间为:11:13:16

    2020-07-07 11:13:16.455 INFO 32360 --- [ PASCAL-3] c.e.multithreading.service.TestService : 当前线程为:PASCAL-3,方法开始时间为:11:13:16

    2020-07-07 11:13:21.456 INFO 32360 --- [ PASCAL-2] c.e.multithreading.service.TestService : 当前线程为:PASCAL-2,方法结束时间为:11:13:21

    2020-07-07 11:13:21.457 INFO 32360 --- [ PASCAL-4] c.e.multithreading.service.TestService : 当前线程为:PASCAL-4,方法开始时间为:11:13:21

    2020-07-07 11:13:26.456 INFO 32360 --- [ PASCAL-3] c.e.multithreading.service.TestService : 当前线程为:PASCAL-3,方法结束时间为:11:13:26

    2020-07-07 11:13:26.457 INFO 32360 --- [ PASCAL-5] c.e.multithreading.service.TestService : 当前线程为:PASCAL-5,方法开始时间为:11:13:26

    2020-07-07 11:13:31.458 INFO 32360 --- [ PASCAL-4] c.e.multithreading.service.TestService : 当前线程为:PASCAL-4,方法结束时间为:11:13:31

    2020-07-07 11:13:31.459 INFO 32360 --- [ PASCAL-1] c.e.multithreading.service.TestService : 当前线程为:PASCAL-1,方法开始时间为:11:13:31

    2020-07-07 11:13:36.458 INFO 32360 --- [ PASCAL-5] c.e.multithreading.service.TestService : 当前线程为:PASCAL-5,方法结束时间为:11:13:36

    2020-07-07 11:13:36.460 INFO 32360 --- [ PASCAL-2] c.e.multithreading.service.TestService : 当前线程为:PASCAL-2,方法开始时间为:11:13:36

    2020-07-07 11:13:41.459 INFO 32360 --- [ PASCAL-1] c.e.multithreading.service.TestService : 当前线程为:PASCAL-1,方法结束时间为:11:13:41

    2020-07-07 11:13:41.462 INFO 32360 --- [ PASCAL-3] c.e.multithreading.service.TestService : 当前线程为:PASCAL-3,方法开始时间为:11:13:41

    2020-07-07 11:13:46.461 INFO 32360 --- [ PASCAL-2] c.e.multithreading.service.TestService : 当前线程为:PASCAL-2,方法结束时间为:11:13:46

    每隔五秒执行一次

    -----------------------分割线-----------------------

    如果有多个定时任务,每个任务需要在不同的线程间处理的话,就要用另外的配置:如下:

    /**

    * 配置多个schedule的线程配置

    */

    @Configuration

    @EnableScheduling

    public class ScheduleConfig implements SchedulingConfigurer{

    /*

    * 并行任务

    */

    public void configureTasks(ScheduledTaskRegistrar taskRegistrar)

    {

    ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();

    taskScheduler.setThreadNamePrefix("Schedule-Task-");

    taskScheduler.setPoolSize(5);

    taskScheduler.setAwaitTerminationSeconds(60);

    taskScheduler.setWaitForTasksToCompleteOnShutdown(true);

    taskScheduler.initialize();

    taskRegistrar.setTaskScheduler(taskScheduler);

    }

    }

    业务如下:

    @Scheduled(cron = "*/5 * * * * ?")

    public void test1(){

    SimpleDateFormat format=new SimpleDateFormat("HH:mm:ss");

    try {

    logger.info("当前线程为:"+Thread.currentThread().getName()+",方法开始时间为:"+format.format(new Date()));

    Thread.sleep(10000);

    logger.info("当前线程为:"+Thread.currentThread().getName()+",方法结束时间为:"+format.format(new Date()));

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    @Scheduled(cron = "*/5 * * * * ?")

    public void test2(){

    SimpleDateFormat format=new SimpleDateFormat("HH:mm:ss");

    try {

    logger.info("当前线程为:"+Thread.currentThread().getName()+",方法开始时间为:"+format.format(new Date()));

    Thread.sleep(10000);

    logger.info("当前线程为:"+Thread.currentThread().getName()+",方法结束时间为:"+format.format(new Date()));

    } catch (InterruptedException e) {

    e.printStackTrace();

    }

    }

    测试结果:

    2020-07-07 11:34:53.101 INFO 27440 --- [ main] c.e.m.MultithreadingApplication : Started MultithreadingApplication in 1.147 seconds (JVM running for 1.74)

    2020-07-07 11:34:55.002 INFO 27440 --- [Schedule-Task-2] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-2,方法开始时间为:11:34:55

    2020-07-07 11:34:55.002 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法开始时间为:11:34:55

    2020-07-07 11:35:05.003 INFO 27440 --- [Schedule-Task-2] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-2,方法结束时间为:11:35:05

    2020-07-07 11:35:05.003 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法结束时间为:11:35:05

    2020-07-07 11:35:10.001 INFO 27440 --- [Schedule-Task-2] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-2,方法开始时间为:11:35:10

    2020-07-07 11:35:10.001 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法开始时间为:11:35:10

    2020-07-07 11:35:20.001 INFO 27440 --- [Schedule-Task-2] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-2,方法结束时间为:11:35:20

    2020-07-07 11:35:20.002 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法结束时间为:11:35:20

    2020-07-07 11:35:25.001 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法开始时间为:11:35:25

    2020-07-07 11:35:25.003 INFO 27440 --- [Schedule-Task-3] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-3,方法开始时间为:11:35:25

    2020-07-07 11:35:35.001 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法结束时间为:11:35:35

    2020-07-07 11:35:35.003 INFO 27440 --- [Schedule-Task-3] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-3,方法结束时间为:11:35:35

    2020-07-07 11:35:40.002 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法开始时间为:11:35:40

    2020-07-07 11:35:40.002 INFO 27440 --- [Schedule-Task-5] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-5,方法开始时间为:11:35:40

    2020-07-07 11:35:50.002 INFO 27440 --- [Schedule-Task-1] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-1,方法结束时间为:11:35:50

    2020-07-07 11:35:50.002 INFO 27440 --- [Schedule-Task-5] c.e.multithreading.service.TestService : 当前线程为:Schedule-Task-5,方法结束时间为:11:35:50

    以上这篇Springboot集成定时器和多线程异步处理操作就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • Python多线程异步调用

    2021-01-28 16:09:29
      本博客主要实现一个python多线程异步调用的demo。   程序功能简介:调用main_func作为主程序,主程序内部创建两个线程,分别建立线程ID、线程名和线程内部执行延迟时间,两个线程内部分别调用函数print_time...
  • @EnableAsync // 启用异步任务 public class AsyncConfiguration { // 声明一个线程池(并指定线程池的名字) @Bean("AsyncTask") public Executor asyncExecutor() { ThreadPoolTaskExecutor executor = new ...
  • Java使用多线程异步执行批量更新操作

    千次阅读 热门讨论 2021-01-11 00:16:32
    因此,开多线程来执行批量任务是十分重要的一种批量操作思路,其实这种思路实现起来也十分简单,就拿批量更新的操作举例: 整体流程图 步骤 获取需要进行批量更新的大集合A,对大集合进行拆分操作,分成N个小集合A...
  • 在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单 真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做...
  • Future接口是Java标准API的一...启动多线程任务2.处理其他事3.收集多线程任务结果。从而实现了非阻塞的任务调用。在途中遇到一个问题,那就是虽然能异步获取结果,但是Future的结果需要通过isdone来判断是否有结果,...
  • 在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单 真实数据一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据.去蛋糕店买蛋糕,不需要等蛋糕做...
  • 直接另开一个线程执行即可,但是如果遇到一些需要获取执行结果的业务,就只能为了多线程异步方式再引入线程间通信逻辑,便显得捉襟见肘。         jdk 1.5以后新引入了Future和Calla
  • java多线程异步执行

    2021-02-26 21:42:08
    /*Java通过Executors提供四种线程池,分别为: newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool 创建一个定长线程池,可...
  • 最近在研究Spring Boot中的异步处理,发现涉及到异步和多线程的很多知识点,就先写几篇关于异步与多线程的文章,带大一起回顾或学习一下相关的知识点。下面开始正文内容: 前言 在本文中,我们通过一些通俗易懂的...
  • SpringBoot多线程异步查询步骤 1、创建线程池 import java.util.concurrent.ThreadPoolExecutor; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation....
  • } } 继承Thread类 通过继承Thread类,重写run()方法,随后实例调用start()方法启动 public class ThreadTest extends Thread{ @Override public void run() { System.out.println("Thread 方式创建的线程");...
  • 异步处理最大的好处是可以提高并发量,不阻塞当前线程。其实 Spring MVC 也支持了异步处理,本文记录下相关的技术点。 异步处理 demo 如果要启用异步返回,需要开启 @EnableAsync。如下的代码中,使用 Deferred
  • 于是采用异步处理方法,进行性能优化。 package com.test; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; public class MyExecutor { //创建线程池
  • 多线程 异步

    2020-12-20 16:24:56
    多线程 异步异步操作的本质:DMA多线程的缺点适用范围异步和多线程关系Future 模式实现java 多线程异步调用 异步操作的本质:DMA DMA就是直 接内存访问的意思,也就是说,拥有DMA功能的硬件在和内存进行数据交换的...
  • 第 1 步:创建 DeferredResult(超时时间[毫秒],超时回调的代码) 第 2 步:在子线程异步处理业务,调用 DeferredResult 的 setResult 方法,设置最终返回到客户端的结果,此方法调用以后,客户端将接收到返回值,...
  • 多线程异步的区别

    2020-12-21 15:22:41
    文章目录前言一、什么是异步二、什么是多线程三、异步多线程异同点四、异步多线程适用场景五、思考题总结 前言 异步是一种现象结果,多线程是实现其结果的一种手段。不可将多线程编程与异步划上等号 譬如,单...
  • 今天就来讨论一下使用【优化sql】和【多线程】方式提升全表查询效率 ⚠️注意,这只是简单测试,用于讲解思路,真实情况会更加的复杂,效率可能会相对受到影响,而且也会受硬件配置的影响,所以不是绝对的 前置准备...
  • 利用java异步编程的操作,将分解的sql异步执行并最终汇总数据。这里用到了CountDownLatch和ExecutorService,// 获取时间段所有天数List days = MyDateUtils.getDays(requestParams.getStartTime(), requestParams....
  • 因此,开多线程来执行批量任务是十分重要的一种批量操作思路,其实这种思路实现起来也十分简单,就拿批量更新的操作举例:整体流程图步骤 获取需要进行批量更新的大集合A,对大集合进行拆分操作,分成N个小集合A-1 ~...
  • 我回答了一个听起来与您的问题惊人相似的问题,其中有人有一个家庭作业来创建一个客户机-服务器设置,每个连接都在一个新线程处理:...关于异步线程的额外信息There are only two w...
  • 虽然标题是“生产者消费者模型实现多线程异步交互”,但这里要说的应该还包括Python的消息队列,因为这里多线程异步交互是通过Python的消息队列来实现的,因此主要内容如下:1.生产者消费者模型通过厨师做包子与顾客...
  • 启动类添加 @EnableAsync 注解 开启线程池(多线程) 新增异步添加接口 package com.chalk.service; import com.chalk.model.Student; import com.chalk.model.Teacher; import com.chalk.model.UserDeviceRel...
  • 回到我的问题上,是否可以使用多线程或多处理并行运行此程序。我听说您可以使用ThreadPoolExecutor或ProcessPoolExecutor。在import randomimport asynciofrom aiohttp import ClientSessionimport timefrom con...
  • 本文目录CompletableFuture ...合并个任务的结果:allOf 与 anyOf9.其它一些方法   创建线程时,除了 实现Callable接口,重写call()方法,通过FutureTask包装器来创建Thread线程,通过 get() 方法获得返回值外。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 366,915
精华内容 146,766
关键字:

多线程异步处理