【JavaWeb】定时任务和批量插入数据库数据

小秀_heo

已于 2024-08-28 10:33:41 修改

阅读量129

点赞数 2

分类专栏： JavaWeb 文章标签：数据库 java 开发语言

于 2024-08-28 08:43:03 首次发布

本文链接：https://blog.csdn.net/XiugongHao/article/details/141613167

版权

JavaWeb 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

定时任务

需要在项目启动类添加注解开启支持定时任务：

在这里插入图片描述

以下示例是定时任务插入数据的操作：

package com.yupi.yupao.once.importuser;

import com.yupi.yupao.mapper.UserMapper;
import com.yupi.yupao.model.domain.User;
import org.springframework.stereotype.Component;
import org.springframework.util.StopWatch;

import javax.annotation.Resource;

/**
 * 导入用户任务
 *
 */
@Component
public class InsertUsers {

    @Resource
    private UserMapper userMapper;

    /**
     * 批量插入用户
     */
     // initialDelay 每隔多少毫秒执行一次 fixedRate 执行的时间间隔 所以两个结合起来可以控制定时任务只执行一次
//    @Scheduled(initialDelay = 5000, fixedRate = Long.MAX_VALUE)
    public void doInsertUsers() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        final int INSERT_NUM = 1000;
        for (int i = 0; i < INSERT_NUM; i++) {
            User user = new User();
            user.setUsername("假鱼皮");
            user.setUserAccount("fakeyupi");
            user.setAvatarUrl("https://636f-codenav-8grj8px727565176-1256524210.tcb.qcloud.la/img/logo.png");
            user.setGender(0);
            user.setUserPassword("12345678");
            user.setPhone("123");
            user.setEmail("123@qq.com");
            user.setTags("[]");
            user.setUserStatus(0);
            user.setUserRole(0);
            user.setPlanetCode("11111111");
            userMapper.insert(user);
        }
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }
}

这种插入方法过程：建立数据库连接会话，插入一条数据，关闭数据库连接会话。如果需要插入非常多条数据，可能等待非常久（1000条90s）。

上述 for 循环插入数据的问题：

建立和释放数据库连接（批量查询解决）
for 循环是绝对线性的（并发）

并发注意执行的先后顺序无影响，不要使用非并发类的集合。

package com.yupi.yupao.service;

import com.yupi.yupao.model.domain.User;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.util.StopWatch;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

/**
 * 导入用户测试
 *
 */
@SpringBootTest
public class InsertUsersTest {

    @Resource
    private UserService userService;

	// 核心线程数(默认运行的线程数): 40, 最大线程数：1000，存活时间；10000, 单位，任务队列长度：10000
    private ExecutorService executorService = new ThreadPoolExecutor(40, 1000, 10000, TimeUnit.MINUTES, new ArrayBlockingQueue<>(10000));

    /**
     * 批量插入用户
     */
    @Test
    public void doInsertUsers() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 一共插入 10w 条数据
        final int INSERT_NUM = 100000;
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < INSERT_NUM; i++) {
            User user = new User();
            user.setUsername("原_创 【鱼_皮】https://t.zsxq.com/0emozsIJh");
            user.setUserAccount("fakeyupi");
            user.setAvatarUrl("https://636f-codenav-8grj8px727565176-1256524210.tcb.qcloud.la/img/logo.png");
            user.setGender(0);
            user.setUserPassword("12345678");
            user.setPhone("123");
            user.setEmail("123@qq.com");
            user.setTags("[]");
            user.setUserStatus(0);
            user.setUserRole(0);
            user.setPlanetCode("11111111");
            userList.add(user);
        }
        // 18 秒 10 万条
        // 1w 条为一组
        userService.saveBatch(userList, 10000);
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }

    /**
     * 并发批量插入用户
     */
    @Test
    public void doConcurrencyInsertUsers() {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        // 分 20 组 一组 5000 条
        int batchSize = 5000;
        int j = 0;
        List<CompletableFuture<Void>> futureList = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            List<User> userList = new ArrayList<>();
            while (true) {
                j++;
                User user = new User();
                user.setUsername("假鱼皮");
                user.setUserAccount("fakeyupi");
                user.setAvatarUrl("https://636f-codenav-8grj8px727565176-1256524210.tcb.qcloud.la/img/logo.png");
                user.setGender(0);
                user.setUserPassword("12345678");
                user.setPhone("123");
                user.setEmail("123@qq.com");
                user.setTags("[]");
                user.setUserStatus(0);
                user.setUserRole(0);
                user.setPlanetCode("11111111");
                userList.add(user);
                if (j % batchSize == 0) {
                    break;
                }
            }
            // 异步执行
            CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
                System.out.println("threadName: " + Thread.currentThread().getName());
                userService.saveBatch(userList, batchSize);
            }, executorService);
            futureList.add(future);
        }
        CompletableFuture.allOf(futureList.toArray(new CompletableFuture[]{})).join();
        // 6 秒 10 万条
        stopWatch.stop();
        System.out.println(stopWatch.getTotalTimeMillis());
    }
}

用户插入单元测试，注意打包时要删掉或忽略，不然打一次包就插入一次
// CPU 密集型：分配的核心线程数 = CPU - 1
// IO 密集型：分配的核心线程数可以大于 CPU 核数

默认情况下，上述不同的分组组合结果也会不同，而且并不是一组数越大越好，因为线程数如果不自定义的话是默认的，根据不同的电脑，默认分配的线程数是不一样的。

也就是说，一部分线程干了一次活，可能也有一部分线程干了两次活。所以干了两次活的这部分线程就是时间消耗的主要原因。

所以后面我们自定义的线程池可能会提高性能。

数据预热

问题：第一个用户访问还是很慢（因为只有在被请求后的数据才可能被缓存），也能一定程度上保护数据库。

缓存预热的优点：

解决上面的问题，可以让用户始终访问很快

缺点：

增加开发成本（你要额外的开发、设计）
预热的时机和时间如果错了，有可能你缓存的数据不对或者太老
需要占用额外空间

怎么缓存预热？

定时
模拟触发（手动触发）

实现：

用定时任务，每天刷新所有用户的推荐列表

注意点：

缓存预热的意义（新增少、总用户多）
缓存的空间不能太大，要预留给其他缓存空间
缓存数据的周期（此处每天一次）
定时任务实现
Spring Scheduler（spring boot 默认整合了）
Quartz（独立于 Spring 存在的定时任务框架）
XXL-Job 之类的分布式任务调度平台（界面 + sdk）

第一种方式：

主类开启 @EnableScheduling
给要定时执行的方法添加 @Scheduling 注解，指定 cron 表达式或者执行频率

cron 表达式：
● https://cron.qqe2.com/
● https://www.matools.com/crontab/

package com.yupi.yupao.job;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yupi.yupao.mapper.UserMapper;
import com.yupi.yupao.model.domain.User;
import com.yupi.yupao.service.UserService;
import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * 缓存预热任务
 *
 */
@Component
@Slf4j
public class PreCacheJob {

    @Resource
    private UserService userService;

    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    @Resource
    private RedissonClient redissonClient;

    // 重点用户
    private List<Long> mainUserList = Arrays.asList(1L);

    // 每天执行，预热推荐用户
    @Scheduled(cron = "0 31 0 * * *")
    public void doCacheRecommendUser() {
        RLock lock = redissonClient.getLock("yupao:precachejob:docache:lock");
        try {
            // 只有一个线程能获取到锁
            if (lock.tryLock(0, -1, TimeUnit.MILLISECONDS)) {
                System.out.println("getLock: " + Thread.currentThread().getId());
                for (Long userId : mainUserList) {
                    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
                    Page<User> userPage = userService.page(new Page<>(1, 20), queryWrapper);
                    String redisKey = String.format("yupao:user:recommend:%s", userId);
                    ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
                    // 写缓存
                    try {
                        valueOperations.set(redisKey, userPage, 30000, TimeUnit.MILLISECONDS);
                    } catch (Exception e) {
                        log.error("redis set key error", e);
                    }
                }
            }
        } catch (InterruptedException e) {
            log.error("doCacheRecommendUser error", e);
        } finally {
            // 只能释放自己的锁
            if (lock.isHeldByCurrentThread()) {
                System.out.println("unLock: " + Thread.currentThread().getId());
                lock.unlock();
            }
        }
    }

}

定时任务的问题

控制定时任务的执行：

浪费资源，想象 10000 台服务器同时 “打鸣”
脏数据，比如重复插入

要控制定时任务在同一时间只有 1 个服务器能执行：

分离定时任务程序和主程序，只在 1 个服务器运行定时任务。成本太大
写死配置，每个服务器都执行定时任务，但是只有 ip 符合配置的服务器才真实执行业务逻辑，其他的直接返回。成本最低；但是我们的 IP 可能是不固定的，把 IP 写的太死了
动态配置，配置是可以轻松的、很方便地更新的（代码无需重启），但是只有 ip 符合配置的服务器才真实执行业务逻辑。问题：服务器多了、IP 不可控还是很麻烦，还是要人工修改
○ 数据库
○ Redis
○ 配置中心（Nacos、Apollo、Spring Cloud Config）
分布式锁，只有抢到锁的服务器才能执行业务逻辑。坏处：增加成本；好处：不用手动配置，多少个服务器都一样。单机就会存在单点故障。

小秀_heo

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
【JavaWeb】定时任务和批量插入数据库数据

默认情况下，上述不同的分组组合结果也会不同，而且并不是一组数越大越好，因为线程数如果不自定义的话是默认的，根据不同的电脑，默认分配的线程数是不一样的。这种插入方法过程：建立数据库连接会话，插入一条数据，关闭数据库连接会话。也就是说，一部分线程干了一次活，可能也有一部分线程干了两次活。问题：第一个用户访问还是很慢（因为只有在被请求后的数据才可能被缓存），也能一定程度上保护数据库。// CPU 密集型：分配的核心线程数 = CPU - 1。并发注意执行的先后顺序无影响，不要使用非并发类的集合。
复制链接

扫一扫