线程池+触发器实现动态创建定时器

最新推荐文章于 2025-03-13 23:45:22 发布
置顶 最新推荐文章于 2025-03-13 23:45:22 发布
阅读量748 收藏 6
点赞数 4
分类专栏： 定时器 文章标签： 触发器 java quartz
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_37608876/article/details/103678961
版权

用线程池 + 触发器实现动态去创建定时器的功能，仅做参考，有需要的可根据自身的业务需求做相关的调整

（有帮助的话希望支持下）

先贴个流程图：
在这里插入图片描述
思路说明:

1、ThreadPoolTaskScheduler：线程池任务调度类，能够开启线程池进行任务调度。
2、ThreadPoolTaskScheduler.schedule()：创建一个定时计划ScheduledFuture，在这个方法需要添加两个参数，Runnable（线程接口类） 和CronTrigger（定时任务触发器）
3、在ScheduledFuture中有一个cancel可以停止定时任务。

案例说明：

本例用到6个类：
1、QuatzDynamicScheduled：业务逻辑入口
2、ScheduledRunnable：线程池
3、QuatzScheduled：业务需求，指定时间执行的定时器
4、ScheduledFutureMap：记录创建的定时器
5、MeetingScheduled：业务实体封装
6、MeetingUserScheduled：业务实体封装

注意：相关操作数据库的不贴出来。

所需Jar包： Quartz相关依赖包
源码：

/**
 * <p>Description</p>
 * <p>动态创建定时器</p>
 * ======================
 * ======================
 *
 * @Author created by lgy
 * @Date 2019/12/19
 */
@Component
public class QuatzDynamicScheduled implements CommandLineRunner {

    private static final Logger log = LoggerFactory.getLogger(QuatzDynamicScheduled.class);

    @Autowired
    private ThreadPoolTaskScheduler poolTaskScheduler;
    @Autowired
    private ITDynamicTimerService dynamicTimerService;
    @Autowired
    private IMeetingService meetingService;
    @Autowired
    private IMeetingUserService meetingUserService;
    @Autowired
    private ITUserAttendeeService userAttendeeService;
    private ScheduledFuture<?> future;

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        return new ThreadPoolTaskScheduler();
    }

    /**
     * 关闭触发器.
     *
     * @param name
     * @return
     */
    public void closeDynamicScheduled(String name) {
        future = ScheduledFutureMap.getFutures().get(name);
        if (future != null) {
            future.cancel(true);
            ScheduledFutureMap.getFutures().remove(name);
        }
    }

    /**
     * 添加触发器.
     *
     * @param meetingScheduled
     * @param type
     * @param cron
     */
    public void addScheduled(MeetingScheduled meetingScheduled, Integer type, String cron) {
        String name = meetingScheduled.getName();
        /**
         * 判断如果触发器已经存在，先关闭再创建新的触发器
         * 预防情况：
         * 1、修改与会人员触发.
         * 2、修改通知时间触发.
         */
        if (ScheduledFutureMap.getFutures().get(name) != null) {
            closeDynamicScheduled(name);
        }
        ScheduledRunnable scheduledRunnable = new ScheduledRunnable(meetingScheduled, type, name);
        CronTrigger trigger = new CronTrigger(cron);
        future = this.poolTaskScheduler.schedule(scheduledRunnable, trigger);
        ScheduledFutureMap.getFutures().put(name, future);
    }

    /**
     * 添加动态定时器.
     *
     * @param meetingScheduled
     * @param type             0:发送短信  1:发送邮件 2:发送短信和邮件
     * @param cron             cron规则
     *                         cron表达式中各时间元素使用空格进行分割，表达式有至少6个（也可能7个）分别表示如下含义：
     *                         <p>
     *                         秒（0~59）
     *                         分钟（0~59）
     *                         小时（0~23）
     *                         天（月）（0~31，但是你需要考虑你月的天数）
     *                         月（0~11）
     *                         天（星期）（1~7 1=SUN 或 SUN，MON，TUE，WED，THU，FRI，SAT）
     *                         年份（1970－2099）
     *                         其中每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.
     *                         <p>
     *                         0 0 10,14,16 * * ? 每天上午10点，下午2点，4点
     *                         0 0/30 9-17 * * ?   朝九晚五工作时间内每半小时
     *                         0 0 12 ? * WED 表示每个星期三中午12点
     *                         "0 0 12 * * ?" 每天中午12点触发
     *                         "0 15 10 ? * *" 每天上午10:15触发
     *                         "0 15 10 * * ?" 每天上午10:15触发
     *                         "0 15 10 * * ? *" 每天上午10:15触发
     *                         "0 15 10 * * ? 2005" 2005年的每天上午10:15触发
     *                         "0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发
     *                         "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发
     *                         "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
     *                         "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发
     *                         "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发
     *                         "0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发
     *                         "0 15 10 15 * ?" 每月15日上午10:15触发
     *                         "0 15 10 L * ?" 每月最后一日的上午10:15触发
     *                         "0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发
     *                         "0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
     *                         "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发
     * @return
     */
    public boolean addScheduledToSendMsg(MeetingScheduled meetingScheduled, Integer type, String cron) {
        log.info("动态添加定时器，参数列表：{'type':{},'cron':{},'meetingScheduled':{}}", new Object[]{type, cron, meetingScheduled});
        if (logicNotNull(meetingScheduled)) {
            Date notiFyTime = meetingScheduled.getNotifyTime();
            addOrUpdateRecordToDataBase(notiFyTime, meetingScheduled.getName());
            /*判断 只有为当天的通知时间才创建触发器，否则只添加到数据库*/
            if (isToday(notiFyTime.getTime())) {
                addScheduled(meetingScheduled, type, cron);
            }
            return true;
        }
        return false;
    }

    /**
     * 添加动态定时器.
     *
     * @param meetingScheduled
     * @param type
     * @param notifyTime
     * @return
     */
    public boolean addScheduledToSendMsg(MeetingScheduled meetingScheduled, Integer type, Date notifyTime) {
        log.info("动态添加定时器，参数列表：{'type':{},'notifyTime':{},'meetingScheduled':{}}", new Object[]{type, notifyTime, meetingScheduled});
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(notifyTime);
        int year = calendar.get(Calendar.YEAR),
                month = calendar.get(Calendar.MONTH),
                day = calendar.get(Calendar.DATE),
                hour = calendar.get(Calendar.HOUR_OF_DAY),
                min = calendar.get(Calendar.MINUTE),
                sec = calendar.get(Calendar.SECOND);
        String cron = sec + " " + min + " " + hour + " " + day + " " + month + " ? " + year;
        addScheduledToSendMsg(meetingScheduled, type, cron);
        return false;
    }

    /**
     * 添加动态定时器
     *
     * @param meeting
     * @param userAttendees
     * @param type
     * @param cron
     * @return
     */
    public boolean addScheduledToSendMsg(Meeting meeting, List<UserAttendee> userAttendees, Integer type, String cron) {
        if (userAttendees != null && userAttendees.size() > 0) {
            List<MeetingUserScheduled> users = new ArrayList<>();
            for (UserAttendee userAttendee : userAttendees) {
                MeetingUserScheduled user = new MeetingUserScheduled();
                user.setEmail(userAttendee.getEmail());
                user.setName(userAttendee.getName());
                user.setPhone(userAttendee.getPhone());
                // 校验用户的非空参数，不满足 直接返回
                if (!logicNotNull(user)) {
                    return false;
                }
                users.add(user);
            }
            MeetingScheduled meetingScheduled = new MeetingScheduled();
            meetingScheduled.setEndTime(meeting.getEndTime());
            meetingScheduled.setMeetingContent(meeting.getDescription());
            meetingScheduled.setMeetingTitle(meeting.getTitle());
            meetingScheduled.setRoomName(meeting.getRoomIdName());
            meetingScheduled.setStartTime(meeting.getStartTime());
            meetingScheduled.setNotifyTime(meeting.getNotificationTime());
            meetingScheduled.setName(meeting.getName());
            meetingScheduled.setUsers(users);
            return addScheduledToSendMsg(meetingScheduled, type, cron);
        }
        return false;
    }

    /**
     * 添加动态定时器
     *
     * @param meeting
     * @param userAttendees
     * @param type
     * @param notifyTime
     * @return
     */
    public boolean addScheduledToSendMsg(Meeting meeting, List<UserAttendee> userAttendees, Integer type, Date notifyTime) {
        if (userAttendees != null && userAttendees.size() > 0) {
            List<MeetingUserScheduled> users = new ArrayList<>();
            for (UserAttendee userAttendee : userAttendees) {
                MeetingUserScheduled user = new MeetingUserScheduled();
                user.setEmail(userAttendee.getEmail());
                user.setName(userAttendee.getName());
                user.setPhone(userAttendee.getPhone());
                // 校验用户的非空参数，不满足 直接返回
                if (!logicNotNull(user)) {
                    return false;
                }
                users.add(user);
            }
            MeetingScheduled meetingScheduled = new MeetingScheduled();
            meetingScheduled.setEndTime(meeting.getEndTime());
            meetingScheduled.setMeetingContent(meeting.getDescription());
            meetingScheduled.setMeetingTitle(meeting.getTitle());
            meetingScheduled.setRoomName(meeting.getRoomIdName());
            meetingScheduled.setStartTime(meeting.getStartTime());
            meetingScheduled.setNotifyTime(meeting.getNotificationTime());
            meetingScheduled.setName(meeting.getName());
            meetingScheduled.setUsers(users);
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(notifyTime);
            int year = calendar.get(Calendar.YEAR),
                    month = calendar.get(Calendar.MONTH),
                    day = calendar.get(Calendar.DATE),
                    hour = calendar.get(Calendar.HOUR_OF_DAY),
                    min = calendar.get(Calendar.MINUTE),
                    sec = calendar.get(Calendar.SECOND);
            String cron = sec + " " + min + " " + hour + " " + day + " " + month + " ? " + year;
            return addScheduledToSendMsg(meetingScheduled, type, cron);
        }
        return false;
    }

    /**
     * 检验会议通知的内容相关字段非空
     *
     * @param meetingScheduled
     * @return
     */
    private boolean logicNotNull(MeetingScheduled meetingScheduled) {
        boolean b1 = meetingScheduled.getEndTime() != null,
                b3 = logicNotNull(meetingScheduled.getMeetingTitle()),
                b4 = logicNotNull(meetingScheduled.getRoomName()),
                b5 = meetingScheduled.getStartTime() != null,
                b6 = meetingScheduled.getUsers() != null && meetingScheduled.getUsers().size() > 0,
                b7 = meetingScheduled.getNotifyTime() != null,
                b8 = logicNotNull(meetingScheduled.getName());
        if (b1 && b3 && b4 && b5 && b6 && b7 && b8) {
            return true;
        }
        return false;
    }

    /**
     * 校验会议通知用户成员相关字段不为空
     *
     * @param meetingUserScheduled
     * @return
     */
    private boolean logicNotNull(MeetingUserScheduled meetingUserScheduled) {
        boolean b1 = meetingUserScheduled.getEmail() != null && !meetingUserScheduled.equals(""),
                b2 = meetingUserScheduled.getName() != null && !meetingUserScheduled.equals(""),
                b3 = meetingUserScheduled.getPhone() != null && !meetingUserScheduled.equals("");
        if (b1 && b2 && b3) {
            return true;
        }
        return false;
    }

    /**
     * 字符串判断非空
     *
     * @param param
     * @return
     */
    private boolean logicNotNull(String param) {
        if (param != null && !param.equals("")) {
            return true;
        }
        return false;
    }

    /**
     * 添加 or 更新
     * 定时器记录到数据库
     *
     * @param notifyTime
     */
    private void addOrUpdateRecordToDataBase(Date notifyTime, String name) {
        try {
            TDynamicTimer dynamicTimer = new TDynamicTimer();
            dynamicTimer.setCreateTime(new Date());
            dynamicTimer.setDisable(1);
            dynamicTimer.setName(name);
            dynamicTimer.setNotifyTime(notifyTime);
            Map<String, Object> params = new HashMap<>();
            params.put("name", name);
            List<TDynamicTimer> dynamicTimers = this.dynamicTimerService.selectByMap(params);
            if (dynamicTimers != null && dynamicTimers.size() > 0) {
                dynamicTimer.setId(dynamicTimers.get(0).getId());
                this.dynamicTimerService.updateById(dynamicTimer);
            } else {
                this.dynamicTimerService.insert(dynamicTimer);
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }
    }

    /**
     * 获取当天所有未执行的定时器
     *
     * @return
     */
    private List<TDynamicTimer> findDynamicTimers() {
        return this.dynamicTimerService.findAllTodayDynamicTimers();
    }

    /**
     * 根据name获取会议信息.
     *
     * @param name
     * @return
     */
    private Meeting getMeetingsByName(String name) {
        Meeting meeting = this.meetingService.getMeetingListByName(name);
        return meeting;
    }

    /**
     * 根据meetingId获取相关与会人员id
     *
     * @param meetingId
     * @return
     */
    private List<Long> findMeetingUsersByMeetingId(Long meetingId) {
        Map<String, Object> params = new HashMap<>();
        params.put("meeting_id", meetingId);
        List<MeetingUser> meetingUsers = this.meetingUserService.selectByMap(params);
        List<Long> userIds = new ArrayList<>();
        if (meetingUsers != null && meetingUsers.size() > 0) {
            for (MeetingUser meetingUser : meetingUsers) {
                userIds.add(meetingUser.getUserId());
            }
        }
        return userIds;
    }

    /**
     * 根据与会人员id获取用户详情信息.
     *
     * @param userIds
     * @return
     */
    private List<UserAttendee> findMeetingUsersInfoByUserIds(List<Long> userIds) {
        List<UserAttendee> userAttendees = this.userAttendeeService.selectBatchIds(userIds);
        return userAttendees;
    }

    /**
     * 判断是否是今天
     *
     * @param time
     * @return
     */
    private boolean isToday(long time) {
        return isThisTime(time, "yyyy-MM-dd");
    }

    private boolean isThisTime(long time, String pattern) {
        Date date = new Date(time);
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        String param = sdf.format(date);//参数时间
        String now = sdf.format(new Date());//当前时间
        if (param.equals(now)) {
            return true;
        }
        return false;
    }

    /**
     * 检测未执行的定时器，并创建当天的定时器
     */
    public void checkUnExecutedTask() {
        List<TDynamicTimer> dynamicTimers = findDynamicTimers();
        if (dynamicTimers != null && dynamicTimers.size() > 0) {
            for (TDynamicTimer dynamicTimer : dynamicTimers) {
                /*会议表 && 触发器记录表 关联的业务流水号*/
                String name = dynamicTimer.getName();
                /**
                 * 1、根据流水号：name 获取相关的 meeting
                 * 2、根据meetingId 获取相关的meetingUsers
                 * 3、调用创建动态定时器方法
                 */
                Meeting meeting = getMeetingsByName(name);
                if (meeting != null) {
                    List<Long> userIds = findMeetingUsersByMeetingId(meeting.getMeetingId());
                    if (userIds != null && userIds.size() > 0) {
                        List<UserAttendee> userAttendees = findMeetingUsersInfoByUserIds(userIds);
                        addScheduledToSendMsg(meeting, userAttendees, meeting.getNotifyType(), meeting.getNotificationTime());
                    }
                }
            }
        }
    }

    /**
     * 应用启动成功后执行该方法
     *
     * @param args
     * @throws Exception
     */
    @Override
    public void run(String... args) throws Exception {
        log.info("应用启动成功，自动检测数据库记录，添加尚未处理的定时器");
        checkUnExecutedTask();
    }

}


/**
 * <p>Description</p>
 * <p>线程池</p>
 * ======================
 * ======================
 *
 * @Author created by lgy
 * @Date 2019/12/19
 */
@Component
public class ScheduledRunnable implements Runnable {

    private static final Logger log = LoggerFactory.getLogger(ScheduledRunnable.class);
    private MeetingScheduled meetingScheduled;
    private Integer type;
    private String name;
    @Autowired
    private ITDynamicTimerService dynamicTimerService;

    public ScheduledRunnable() {
    }

    public ScheduledRunnable(MeetingScheduled meetingScheduled, Integer type, String name) {
        this.meetingScheduled = meetingScheduled;
        this.type = type;
        this.name = name;
    }

    /*执行完关闭定时器*/
    private void closeTimer(String name) {
        log.info("关闭执行完的定时器");
        ScheduledFuture<?> future = ScheduledFutureMap.getFutures().get(name);
        future.cancel(true);
        /*修改数据库记录*/
        dynamicTimerService.closeDynamicTimers(name);
        /*移除Map集合的值*/
        ScheduledFutureMap.getFutures().remove(name);
    }

    @Override
    public void run() {
        switch (type.intValue()) {
            case 0:
                toSendMsg(this.meetingScheduled);
                closeTimer(name);
                break;
            case 1:
                toSendEmail(this.meetingScheduled);
                closeTimer(name);
                break;
            case 2:
                toSendEmailAndMsg(this.meetingScheduled);
                closeTimer(name);
                break;
            default:
                log.error("请注意type的值：\n0:发送短信 \n1:发送邮件  \n 2:同时发送短信和邮件");
                break;
        }
    }

    /*发送短信*/
    public void toSendMsg(MeetingScheduled meetingScheduled) {
        log.info("发送短信，参数列表：{'meetingScheduled':{}}", new Object[]{meetingScheduled});
    }

    /*发送邮件*/
    public void toSendEmail(MeetingScheduled meetingScheduled) {
        log.info("发送邮件，参数列表：{'meetingScheduled':{}}", new Object[]{meetingScheduled});
    }

    /*同时发送短信和邮件*/
    public void toSendEmailAndMsg(MeetingScheduled meetingScheduled) {
        /*发送短信*/
        toSendMsg(meetingScheduled);
        /*发送邮件*/
        toSendEmail(meetingScheduled);
    }

    public MeetingScheduled getMeetingScheduled() {
        return meetingScheduled;
    }

    public void setMeetingScheduled(MeetingScheduled meetingScheduled) {
        this.meetingScheduled = meetingScheduled;
    }

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

/**
 * <p>Description</p>
 * <p>每天执行的定时器</p>
 * ======================
 * ======================
 *
 * @Author created by lgy
 * @Date 2019/12/23
 */
@Component
public class QuatzScheduled {

    @Autowired
    private QuatzDynamicScheduled quatzDynamicScheduled;

    /*每天凌晨0点01分执行*/
    @Scheduled(cron = "0 01 00 ? * *")
    public void everyDay() {
        this.quatzDynamicScheduled.checkUnExecutedTask();
    }
}

/**
 * <p>Description</p>
 * <p>定时器集合</p>
 * ======================
 * ======================
 *
 * @Author created by jy
 * @Date 2019/12/23
 */
public class ScheduledFutureMap {

    private static final Map<String, ScheduledFuture<?>> FUTURES = new HashMap<>();

    public static Map<String, ScheduledFuture<?>> getFutures() {
        return FUTURES;
    }

}

/**
 * <p>Description</p>
 * <p></p>
 * ======================
 * ======================
 *
 * @Author created by jy
 * @Date 2019/12/19
 */
public class MeetingUserScheduled implements Serializable {

    private String name;
    private String phone;
    private String email;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}


/**
 * <p>Description</p>
 * <p></p>
 * ======================
 * ======================
 *
 * @Author created by jy
 * @Date 2019/12/19
 */
public class MeetingScheduled {

    /*会议标题*/
    private String meetingTitle;
    /*会议内容*/
    private String meetingContent;
    /*会议开始时间*/
    private Date startTime;
    /*会议结束时间*/
    private Date endTime;
    /*开会会议室名称*/
    private String roomName;
    /*通知开会时间*/
    private Date notifyTime;
    // 业务流水号
    private String name;
    /*通知的与会人员*/
    private List<MeetingUserScheduled> users;

    public String getMeetingTitle() {
        return meetingTitle;
    }

    public void setMeetingTitle(String meetingTitle) {
        this.meetingTitle = meetingTitle;
    }

    public String getMeetingContent() {
        return meetingContent;
    }

    public void setMeetingContent(String meetingContent) {
        this.meetingContent = meetingContent;
    }

    public Date getStartTime() {
        return startTime;
    }

    public void setStartTime(Date startTime) {
        this.startTime = startTime;
    }

    public Date getEndTime() {
        return endTime;
    }

    public void setEndTime(Date endTime) {
        this.endTime = endTime;
    }

    public String getRoomName() {
        return roomName;
    }

    public void setRoomName(String roomName) {
        this.roomName = roomName;
    }

    public List<MeetingUserScheduled> getUsers() {
        return users;
    }

    public void setUsers(List<MeetingUserScheduled> users) {
        this.users = users;
    }

    public Date getNotifyTime() {
        return notifyTime;
    }

    public void setNotifyTime(Date notifyTime) {
        this.notifyTime = notifyTime;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
springboot+quartz配置实现动态定时任务
10-08 428
https://www.jianshu.com/p/e68c57dc29d3 一、背景 项目中需要用到定时任务模块，记录springboot使用quartz实现动态定时任务，根据数据库的数据来自定义定时任务，主要记录配置代码实现，本机测试是可以实现动态定时任务的。 二、QuartzTask类-定时任务对象 package com.unnet.yjs.entity; import com...
Quartz结合线程池的动态管理
lichongsky1的博客
08-02 1667
Quartz结合线程池的动态管理首先需要明白Quartz的几个核心概念 Quartz是一个非常强大的任务调度框架，可以启动，暂停，恢复，删除，更新，在重启时错过执行时间，可设置misfire规则，也就是设置错过了执行时机怎么办，可以跳过这次执行，等待下一个周期再执行，也可以马上重新执行错过的任务等，具体下面再讲。使用方法比schedule稍微麻烦一点，但三四个class文件也就够了，因为动态控制肯定涉及到前端的，这里不讨论前端如何实现，会从简单的一个demo，到一个具体的动态控制demo，记录一下后端如何设
java 定时器线程池（ScheduledThreadPoolExecutor）的实现
08-19
主要介绍了java 定时器线程池（ScheduledThreadPoolExecutor）,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
线程池与定时器
祭夏的专栏
10-16 2152
1.在什么情况下使用线程池？ 1.单个任务处理的时间比较短 2.将需处理的任务的数量大 2. 使用线程池的好处: 1.减少在创建和销毁线程上所花的时间以及系统资源的开销 2.如不使用线程池，有可能造成系统创建大量线程而导致消耗完系统内存以及”过度切换”。 3. 使用线程池的风险 虽然线程池是构建多线程应用程序的强大机制，但使用它
动态线程池实现原理
最新发布
2301_77744998的博客
03-13 715
动态线程池是一种可以在运行时根据需求动态调整其参数（如核心线程数、最大线程数、队列容量等）的线程池。与静态线程池不同，动态线程池能够在应用程序运行过程中根据负载或配置的变化自动调整自身的行为，以提高资源利用率和系统的响应能力。
线程池，定时器，设计模式
weixin_45137957的博客
08-03 351
线程池，定时器，设计模式 线程池 （1）概述 ​ 程序启动一个新线程成本是比较高的，因为它涉及到要与操作系统进行交互。 ​ 而使用线程池可以很好的提高性能，尤其是当程序中要创建大量生存期很短的线程时，更应该考虑使用线程池。 ​ 线程池里的每一个线程代码结束后，并不会死亡，而是再次回到线程池中成为空闲状态，等待下一个对象来使用。 （2）创建线程池 1.public static ExecutorSe...
Java线程池示例：定时器线程池
学亮编程手记
11-09 733
private static void newScheduledThreadPool() { ScheduledExecutorService service = Executors.newScheduledThreadPool(4); service.scheduleWithFixedDelay(()->{ try { ...
java动态添加线程池_java – 动态线程池
weixin_39908263的博客
02-17 521
在ThreadPoolExecutor中查看下面的APIpublic void setCorePoolSize(int corePoolSize)Sets the core number of threads. This overrides any value set in the constructor.如果新值小于当前值,则当下一个空闲时,多余的现有线程将被终止.如果需要更大,则新线程将启动以...
掌握Quartz定时器：简单与动态配置实现指南
Quartz可以使用简单的配置或动态配置来实现定时任务，而无需关心后台的工作线程管理和调度逻辑。 ### 知识点一：Quartz的基本概念 - **Job（作业）**: 是需要被调度的任务。它是一个接口，实现类定义了具体要执行...
SpringBoot创建动态定时任务的几种方式
m0_74825447的博客
01-01 1126
Quartz是一个功能强大的开源任务调度框架，支持复杂的任务调度需求，如任务的持久化、分布式任务管理、基于数据库的调度等。通过Controller提供API接口，这里的TaskService调用了QartzService的对应接口，并做了一个写数据库读写操作，主要记录定时任务状态、执行记录信息的等。通过TaskScheduler，你可以灵活地安排任务的执行时间，并且可以在运行时动态地创建、取消任务。然而，它的灵活性较差，对于复杂的任务调度需求，或需要动态调整任务时间的场景，可能并不适用。
线程池案例(jdk1.5提供的线程池的创建以及线程池定时器的运用)
工作博客
02-06 1570
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; /** * 线程池案例(jdk1.5提供的线程池的创建以及线程池定时器的运用) * @author 谭飞 * @date 2012-02-03 *
linux下多定时器+线程池的实现（经典）
01-11
// //linux只允许单进程拥有一个定时器，因此在linux下的单进程中要使用多个定时器，则需要自己维护管理 // //这个实现允许用户使用多个自定义的定时器，每个自定义的定时器将周期地被触发直到其被删除。实现的主要思路是： // // i）首先在初始化多定时器（init_mul_timer）时利用setitimer注册一个基本的时间单位（如1s）的定时事件； // // ii）用户需要set_a_timer注册自定义定时器时，在timer_manage管理结构中记录这个定时器的回调函数和定时周期等参数； // // iii）当基本的时间单位到期后（如SIGALRM信号到达时），遍历整个timer_manage，如果有自定义定时器的超时时间到了， //就把该回调函数添加到线程池的任务中，让线程池里面的线程去执行，然后将自定义定时器的超时时间置为最初值0； // // iv）用户通过del_a_timer来删除某个定时器，通 过destroy_mul_timer来删除整个多定时器。
quartz动态创建触发器，动态修改触发器时间
08-05
最近项目在用quartz去定时执行一些方法，这些时间都是动态的，而且还要去动态的去修改这些触发的时间，但是网上资料不全，这里写了个案例希望可以帮到大家，包呢得靠大家自己下载了，我这里用的包是quartz官网上下载的2.2.1的。
android 动态创建线程池,Android四种常见的线程池
weixin_39567870的博客
05-25 486
Android四种常见的线程池引入线程池的好处提升性能，创建和消耗对象时费CPU资源防止内存过度消耗，控制活动线程的数量，防止并发线程过多创建线程，推荐使用Executors的工厂方法来创建线程池，Executors类是官方提供的一个工厂类，它里面封装好了重多功能不一样的线程池。下面介绍一些常用的线程池:public ThreadPoolExecutor(//核心线程数，除非allowCoreTh...
定时器+线程池
H48530的博客
07-10 1052
定时器+线程池定时器线程池创建Executors 定时器 定时器：定时器就像设置一个闹钟，当时间到达后完成某件事情，像JS中的是setTimeout。 (JS中的setInterval是每隔多久执行一次) 1、我们使用定时器的时候，最主要的是小一个任务Runnable，TimeTask就实现了Runnable接口，所以我们直接创建一个Task。 2、设置定时器：Timer timer = new Timer(); 3、调度：利用timer.schedule()方法设置task和delay； schedule
创建个Job定时器
qq_42262965的博客
03-28 197
在configw包中创建一个QuartzConfig类 @Configuration public class QuartzConfig { private static final Logger logger = LoggerFactory.getLogger(QuartzConfig.class); @Autowired private Scheduler sched...
SpringBoot 设置定时任务，求求你别再写死了~，太low了！动态定时任务真的太爽了！...
公众号-老炮说Java
09-24 307
大家好，我是老赵！之前写过文章记录怎么在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。经过网上搜索学习后，特此记录如何在SpringBoot项目中实现动态定时任务。因为只是一个demo，所以只引入了需要的依赖：<dependencies> <dependency&g...
Java开发笔记（一百零五）几种定时器线程池
pinlantu的博客
05-29 244
前面介绍了普通线程池的用法，就大多数任务而言，它们对具体的执行时机并无特殊要求，最多是希望早点跑完早点出结果。不过对于需要定时执行的任务来说，它们要求在特定的时间点运行，并且往往不止运行一次，还要周期性地反复运行。由于普通线程池满足不了此类定时运行的需求，因此Java又提供了定时器线程池来实现定时与周期执行任务的功能。 普通线程池的工具类名叫ExecutorService，定时器线程池的工具类则叫...
动态定时任务
liuwang888的专栏
02-29 273
什么是动态定时任务：是由客户制定生成的，服务端只知道该去执行什么任务，但任务的定时是不确定的（是由客户制定）。      这样总不能修改配置文件每定制个定时任务就增加一个trigger吧，即便允许客户修改配置文件，但总需要重新启动web服务啊，研究了下Quartz在Spring中的动态定时，发现&lt;bean id="cronTrigger" class="org.springframew...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值