多线程处理批量数据


    //int corePoolSize, - 线程池维护线程的最少数量 (core : 核心)
    //int maximumPoolSize, - 线程池的最大线程数。
    //long keepAliveTime, - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。
    //TimeUnit unit, - keepAliveTime 的时间单位。
    //BlockingQueue<Runnable> workQueue, - 用来储存等待执行任务的队列。
    //RejectedExecutionHandler handler)  - 拒绝策略。

//    拒绝策略
//    rejectedExectutionHandler参数字段用于配置绝策略,常用拒绝策略如下
//    AbortPolicy:用于被拒绝任务的处理程序,它将抛出RejectedExecutionException
//    CallerRunsPolicy:用于被拒绝任务的处理程序,它直接在execute方法的调用线程中运行被拒绝的任务。
//    DiscardOldestPolicy:用于被拒绝任务的处理程序,它放弃最旧的未处理请求,然后重试execute。
//    DiscardPolicy:用于被拒绝任务的处理程序,默认情况下它将丢弃被拒绝的任务。

    private static final ThreadPoolExecutor threadPoolExector = new ThreadPoolExecutor(
            3, 10, 10, TimeUnit.SECONDS,
            new ArrayBlockingQueue<Runnable>(100),
            new ThreadPoolExecutor.DiscardOldestPolicy());

    @Autowired
    private ThreadPoolTaskExecutor threadPoolTaskExecutor;

    //方式一:阿里推荐
    @Test
    public void test() {

        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<List<Integer>> executeList = ListSplitUtil.splitList(integerList, 3);

        for (List<Integer> integers : executeList) {
            //开启线程
            threadPoolExector.execute(() -> {
                for (Integer i : integers) {
                    System.out.println("当前线程" + Thread.currentThread().getName() + "执行:" + i);
                }
            });
        }
        //建议主动关闭线程池
        threadPoolExector.shutdown();
    }

    //方式二:spring集成
    @Test
    public void test2() {

        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<List<Integer>> executeList = ListSplitUtil.splitList(integerList, 3);

        threadPoolTaskExecutor.setCorePoolSize(10);
        threadPoolTaskExecutor.setMaxPoolSize(20);
        threadPoolTaskExecutor.setKeepAliveSeconds(10);
        threadPoolTaskExecutor.setQueueCapacity(20);//DiscardPolicy
        threadPoolTaskExecutor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

        for (List<Integer> integers : executeList) {
            //开启线程
            threadPoolTaskExecutor.execute(() -> {
                for (Integer i : integers) {
                    System.out.println("当前线程" + Thread.currentThread().getName() + "执行:" + i);
                }
            });
        }
        //建议主动关闭线程池
        threadPoolTaskExecutor.shutdown();
    }

    //方式三:callable
    @Test
    public void test3() {
        List<Integer> integerList = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<List<Integer>> executeList = ListSplitUtil.splitList(integerList, 3);
        
        for (List<Integer> integers : executeList) {
            Callable myCallable = new Callable() {
            @Override
            public String call() throws Exception {

                for (Integer i : integers) {
                    System.out.println("当前线程" + Thread.currentThread().getName() + "执行:" + i);
                }
                return "success";
            }
        };
        }
        //关闭线程池
        threadPoolTaskExecutor.shutdown();
        
    }

  • 0
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中可以使用ThreadPoolTaskExecutor来实现多线程处理批量数据入库的操作。ThreadPoolTaskExecutor是Spring框架提供的一个线程池实现类,可以方便地管理线程池的创建和销毁,并提供了一些配置参数来控制线程池的行为。 下面是使用ThreadPoolTaskExecutor实现多线程处理批量数据入库的步骤: 1. 首先,需要在项目中引入Spring的依赖,以使用ThreadPoolTaskExecutor类。可以在pom.xml文件中添加以下依赖: ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </dependency> ``` 2. 在代码中创建一个ThreadPoolTaskExecutor对象,并进行相关配置。可以通过在Spring配置文件中配置bean,或者使用Java代码进行配置。以下是一个示例配置: ```java @Configuration @EnableAsync public class ThreadPoolConfig { @Bean public ThreadPoolTaskExecutor taskExecutor() { ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor(); executor.setCorePoolSize(10); // 设置核心线程数 executor.setMaxPoolSize(20); // 设置最大线程数 executor.setQueueCapacity(100); // 设置队列容量 executor.setThreadNamePrefix("MyThread-"); // 设置线程名前缀 executor.initialize(); // 初始化线程池 return executor; } } ``` 3. 在需要进行批量数据入库的地方,使用@Async注解标记方法,并指定使用的线程池。例如: ```java @Service public class DataBatchService { @Autowired private ThreadPoolTaskExecutor taskExecutor; @Async("taskExecutor") public void processBatchData(List<Data> dataList) { // 批量数据入库的逻辑处理 // ... } } ``` 4. 调用processBatchData方法时,会自动使用线程池中的线程进行处理。例如: ```java @Autowired private DataBatchService dataBatchService; public void batchDataInsert(List<Data> dataList) { dataBatchService.processBatchData(dataList); } ``` 这样就可以利用ThreadPoolTaskExecutor实现多线程处理批量数据入库了。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值