task-DelayQueue-订单超时实例（task任务，DelayQueue阻塞队列）

最新推荐文章于 2024-07-07 13:35:40 发布
最新推荐文章于 2024-07-07 13:35:40 发布
阅读量3k 收藏
点赞数
分类专栏： javaee java springmvc 文章标签： spring 实例 异步 class bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/codegeek_jfl/article/details/54708641
版权
java 同时被 3 个专栏收录
31 篇文章 0 订阅
订阅专栏
javaee
5 篇文章 0 订阅
订阅专栏
springmvc
2 篇文章 0 订阅
订阅专栏 
很早就对task，queue有兴趣，今天总结一下，做个笔记。

一、对于多任务异步的项目中，task的作用很普遍，最近学习，和小试牛刀了一下，有一些感悟，做个笔记。
二、使用spring task，配置如下：

<bean id="orderTimeoutService"
        class="com.haohao.order.service.order.impl.OrderTimeoutServiceImpl"
        init-method="init" destroy-method="destroy">
        <property name="handlers">
            <map key-type="com.haohao.order.common.enums.TimeoutTypeEnum">
                <entry key="ORDER" value-ref="orderTimeoutHandler" />
                <entry key="REFUND" value-ref="refundTimeoutHandler" />
            </map>
        </property>
        <property name="loadTimeoutTask" value="${timeout.task.is.load}"/>
    </bean>

    <bean id="orderTimeoutHandler"
        class="com.haohao.order.service.timeout.handler.OrderTimeoutHandler">
        <property name="timeoutActions">
            <map>
                <entry key="wait_buyer_pay_deposit" value-ref="closeOrderAction" />
                <entry key="wait_buyer_pay_all" value-ref="closeOrderAction" />
                <entry key="wait_seller_send" value-ref="sellerSendGoodsAction" />
                <entry key="wait_buyer_receive" value-ref="receiveGoodsAction" />
            </map>
        </property>
    </bean>

    <bean id="refundTimeoutHandler"
        class="com.haohao.order.service.timeout.handler.RefundTimeoutHandler">
        <property name="timeoutActions">
            <map>
                <entry key="wait_seller_agree" value-ref="confirmRefundProtocolAction" />
                <entry key="wait_buyer_modify" value-ref="closeRefundAction" />
                <entry key="wait_buyer_send" value-ref="closeRefundAction" />
                <entry key="wait_seller_receive" value-ref="refundAction" />
                <entry key="wait_customer_service" value-ref="refundCustomerServiceAction" />
            </map>
        </property>
    </bean>

<task:scheduled-tasks scheduler="myScheduler">
    <task:scheduled ref="orderTimeoutService" method="loadRecentlyTimeoutInfo"   cron="${load.order.timeout.period}" />
</task:scheduled-tasks>

    <task:scheduler id="myScheduler" pool-size="5" />

Java代码：

/**
 * 
 */
package com.haohao.order.service.order.impl;

import java.util.List;
import java.util.Map;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.annotation.PreDestroy;
import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;

import com.haohao.order.common.enums.TimeoutTypeEnum;
import com.haohao.order.common.util.BeanUtils;
import com.haohao.order.dal.timeout.OrderTimeoutInfoDAO;
import com.haohao.order.dal.timeout.OrderTimeoutInfoDO;
import com.haohao.order.service.order.OrderTimeoutService;
import com.haohao.order.service.timeout.handler.TimeoutHandler;
import com.haohao.order.service.timeout.model.TimeoutModel;

/**
 * 功能描述：
 * 
 * @author mandy.hu
 */

public class OrderTimeoutServiceImpl implements OrderTimeoutService {
    private static final Logger logger = LoggerFactory.getLogger(OrderTimeoutServiceImpl.class);

    @Resource
    private OrderTimeoutInfoDAO orderTimeoutInfoDAO;

    private DelayQueue<TimeoutModel> timeoutQueue;
    @Autowired(required = false)
    private ExecutorService executorService;
    private Map<TimeoutTypeEnum, TimeoutHandler> handlers;
    private transient boolean running;

    private boolean isLoadTimeoutTask;

    protected void init() {
        if(isLoadTimeoutTask) {
            logger.info("初始化超时队列");
            running = true;
            //初始化一个阻塞队列
            timeoutQueue = new DelayQueue<TimeoutModel>();

            startHandler();
        }
    }
    //这个方法就是用来处理业务的，意思是查询超时的订单，并放在DelayQueue中。
    @Override
    public void loadRecentlyTimeoutInfo() {
        if(isLoadTimeoutTask) {
            logger.info("加载即将超时的信息...");

            List<OrderTimeoutInfoDO> orderTimeoutInfoDOs = orderTimeoutInfoDAO.queryRecentlyOrderTimeoutInfos();

            logger.info("加载即将超时的信息...loadRecentlyTimeoutInfo  orderTimeoutInfoDOs:{}",orderTimeoutInfoDOs);

            List<TimeoutModel> timeoutModels = BeanUtils.convertList(orderTimeoutInfoDOs, TimeoutModel.class);

            if (CollectionUtils.isNotEmpty(timeoutModels)) {
                timeoutQueue.addAll(timeoutModels);
            }
            logger.info("加载即将超时的信息...loadRecentlyTimeoutInfo timeoutQueue:{}",timeoutQueue);
        }
    }

    @PreDestroy
    protected void destroy() {
        running = false;
    }

    private void startHandler() {
        logger.info("启动超时监听线程");

        new Thread(new Runnable() {

            @Override
            public void run() {
                while (running) {
                    try {
                    //阻塞队列执行take()方法，删除队列顶部的一个对象，并返回删除的对象。这个方法是阻塞方法，如果队列中没有对象，这个线程将被阻塞，知道队列中有对象。
                        TimeoutModel timeoutModel = timeoutQueue.take();
//对象交给ExecutorService处理，ExecutorService是一个异步处理机制，相当于一个线程池，意思就把这个take()的对象委托给ExecutorService处理。
                        getExecutorService().execute(new TimeoutHandlerTask(timeoutModel));
                    } catch (InterruptedException e) {
                        logger.warn("处理超时失败", e);
                        e.printStackTrace();
                    } catch (Throwable e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

    class TimeoutHandlerTask implements Runnable {
        private TimeoutModel timeoutModel;

        public TimeoutHandlerTask(TimeoutModel timeoutModel) {
            this.timeoutModel = timeoutModel;
        }

        @Override
        public void run() {
            TimeoutHandler handler = handlers.get(timeoutModel.getTimeoutType());

            if (handler != null) {
                handler.onTimeout(timeoutModel);
            }
        }

    }

    public ExecutorService getExecutorService() {
        if (executorService == null) {
        //得到executorService 对象，其中Runtime.getRuntime()相当于new一个对象，、、Executors.newFixedThreadPool(xxx）最大执行多少个线程的executorService 。
            executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*2);
        }

        return executorService;
    }

    public void setExecutorService(ExecutorService executorService) {
        this.executorService = executorService;
    }

    public Map<TimeoutTypeEnum, TimeoutHandler> getHandlers() {
        return handlers;
    }

    public void setHandlers(Map<TimeoutTypeEnum, TimeoutHandler> handlers) {
        this.handlers = handlers;
    }

    public void setLoadTimeoutTask(boolean isLoadTimeoutTask) {
        this.isLoadTimeoutTask = isLoadTimeoutTask;
    }

}

三：上面注释已经很清楚了，为了防止以后不认识自己写注释，在这里再系统的说一下流程。

  1. 在spring配置文件中，配置task。
<task:scheduled-tasks scheduler="myScheduler">
    <task:scheduled ref="orderTimeoutService" method="loadRecentlyTimeoutInfo"  cron="${load.order.timeout.period}" />
    </task:scheduled-tasks>

<task:scheduler id="myScheduler" pool-size="5" />

其中ref=”orderTimeoutService”是要执行的类，method=”loadRecentlyTimeoutInfo”是要执行这个类中的方法，cron=”${load.order.timeout.period}” 是执行规则多长时间执行，什么周期执行，都可以灵活设置。

  1. 配置执行的类：
<bean id="orderTimeoutService"
        class="com.haohao.order.service.order.impl.OrderTimeoutServiceImpl"
        init-method="init" destroy-method="destroy">
        <property name="handlers">
            <map key-type="com.haohao.order.common.enums.TimeoutTypeEnum">
                <entry key="ORDER" value-ref="orderTimeoutHandler" />
                <entry key="REFUND" value-ref="refundTimeoutHandler" />
            </map>
        </property>
        <property name="loadTimeoutTask" value="${timeout.task.is.load}"/>
    </bean>

    <bean id="orderTimeoutHandler"
        class="com.haohao.order.service.timeout.handler.OrderTimeoutHandler">
        <property name="timeoutActions">
            <map>
                <entry key="wait_buyer_pay_deposit" value-ref="closeOrderAction" />
                <entry key="wait_buyer_pay_all" value-ref="closeOrderAction" />
                <entry key="wait_seller_send" value-ref="sellerSendGoodsAction" />
                <entry key="wait_buyer_receive" value-ref="receiveGoodsAction" />
            </map>
        </property>
    </bean>

    <bean id="refundTimeoutHandler"
        class="com.haohao.order.service.timeout.handler.RefundTimeoutHandler">
        <property name="timeoutActions">
            <map>
                <entry key="wait_seller_agree" value-ref="confirmRefundProtocolAction" />
                <entry key="wait_buyer_modify" value-ref="closeRefundAction" />
                <entry key="wait_buyer_send" value-ref="closeRefundAction" />
                <entry key="wait_seller_receive" value-ref="refundAction" />
                <entry key="wait_customer_service" value-ref="refundCustomerServiceAction" />
            </map>
        </property>
    </bean>

OrderTimeoutServiceImpl类中有两个方法init-method=”init” destroy-method=”destroy”，一个是这个类加载时就会执行的，另一个是这个类销毁时执行的，init-method方法做一些初始化操作。在这个类中有一个属性，是一个map，名字是handlers，handlers中有初始化了两个对象，本文重点不是这里，就不多赘述了

  1. 看看这一个类的具体实现，首先是初始化方法。
protected void init() {
        if(isLoadTimeoutTask) {
            logger.info("初始化超时队列");
            running = true;
            timeoutQueue = new DelayQueue<TimeoutModel>();

            startHandler();
        }
    }

这个方法很简单就是new一个阻塞队列DelayQueue。之后执行startHandler()方法，

private void startHandler() {
        logger.info("启动超时监听线程");

        new Thread(new Runnable() {

            @Override
            public void run() {
                while (running) {
                    try {
                        TimeoutModel timeoutModel = timeoutQueue.take();

                        getExecutorService().execute(new TimeoutHandlerTask(timeoutModel));
                    } catch (InterruptedException e) {
                        logger.warn("处理超时失败", e);
                        e.printStackTrace();
                    } catch (Throwable e) {
                        e.printStackTrace();
                    }
                }
            }
        }).start();
    }

这个方法目的是开起监听，利用的是DelayQueue阻塞队列的特性，方法中调用take()方法，这个方法是阻塞的方法，意思是移除队列中顶部的对象，并返回这个对象，如果队列是空，就会一直等待，等待队列中有对象，线程也处于阻塞的状态，同事就起到了监听的作用。getExecutorService().execute(new TimeoutHandlerTask(timeoutModel))这个方法是把timeoutModel 对象委托给ExecutorService()处理，这边好处理下一个任务。

public ExecutorService getExecutorService() {
        if (executorService == null) {
            executorService = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*2);
        }

        return executorService;
    }

这个就是得到ExecutorService对象， ExecutorService是一个异步处理机制，Executors.newFixedThreadPool(Num);最大能处理Num个线程的ExecutorService。调用ExecutorService的execute（）方法就是委托了。

public void loadRecentlyTimeoutInfo() {
        if(isLoadTimeoutTask) {
            logger.info("加载即将超时的信息...");

            List<OrderTimeoutInfoDO> orderTimeoutInfoDOs = orderTimeoutInfoDAO.queryRecentlyOrderTimeoutInfos();

            logger.info("加载即将超时的信息...loadRecentlyTimeoutInfo  orderTimeoutInfoDOs:{}",orderTimeoutInfoDOs);

            List<TimeoutModel> timeoutModels = BeanUtils.convertList(orderTimeoutInfoDOs, TimeoutModel.class);

            if (CollectionUtils.isNotEmpty(timeoutModels)) {
                timeoutQueue.addAll(timeoutModels);
            }
            logger.info("加载即将超时的信息...loadRecentlyTimeoutInfo timeoutQueue:{}",timeoutQueue);
        }
    }

这个方法就是在spring task中配置要执行的方法，刚开始的时候一直在想在哪里有数据放在了DelayQueue中，就是这里，将想要监听的数据放在DelayQueue中，在startHandler()方法中就能监听到，这是task就是一个闭环了。

Codegeek_jfl
关注
专栏目录
【JUC】Java并发编程从挖坑到入土全解（3-线程池源码分析）
aqin1012的博客
09-28 358
在web开发中，服务器会为每一个请求分配一个线程来处理，如果每次请求都要创建一个线程的话，实现起来虽然简单，但是存在一个问题：如果开发的请求数量非常多，但每个线程执行的时间很短，这样就会频繁的创建和销毁线程，如此会大大降低系统的效率，很有可能出现服务器在创建和销毁线程上花费的时间和消耗的系统资源比实际处理的用户请求的时间和资源还多。于是，线程池应运而生，线程池满足了一个线程执行完一个任务不会被销毁，而是可以继续执行其他任务的目的。
[JUC] 阻塞队列 BlockingQueue
架构探险之道
08-20 383
[JUC] 阻塞队列 BlockingQueue @TOC[目录] BlockingQueue用法
BlockingQueue队列自定义超时时间取消线程池任务
11-25
定义全局线程池，将用户的请求放入自定义队列中，排队等候线程调用，等待超时则自动取消该任务，实现超时可取消的异步任务
其他阻塞队列DelayQueue&PriorityBlockQueue延迟阻塞队列和优先级阻塞队列
wenhuaiteng的专栏
12-04 561
1. DelayQueue延迟阻塞队列。     该队列主要作用是延迟添加元素,mQueue,put(Delay) 2.DelayQueue实例        由于添加到DelayQueue的item延迟10s，所以调用take方法时候需要等待10秒才可以获取到，否则一直block阻塞状态。    DelayQueue mQueue = new DelayQueue(); //添
C#中的Task.Delay(2000).Wait() 与await Task.Delay(2000)
最新发布
07-07 730
C#中的Task.Delay(2000).Wait() 与await Task.Delay(2000)
DelayQueue实现延迟消息
WuTing的专栏
11-10 568
DelayQueue实现延迟消息
FutureTask实现超时任务
CJD的博客
08-03 2473
最近主要在弄一些c/s的东西，以及对接一些外部的接口。 记下一些感觉有用的东西吧。 java在1.5之后又Callable和Future可以获得任务执行完毕后的结果 结合ExecutorService来使用。 使用场景 在调用外部登录接口的时候发现请求过去如果没连上网会一直在请求导致登录界面死机，所以一些连接的请求必须要有一个超时时间，一些耗时的操作的时候也需要一个超时时间来防止死锁...
DelayQueue的用法介绍
凌夜知惜
12-04 1346
XML Code  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
springboot执行延时任务-DelayQueue的使用
weixin_44626952的博客
12-12 3411
DelayQueue简介 在很多场景我们需要用到延时任务，比如给客户异步转账操作超时后发通知告知用户，还有客户下单后多长时间内没支付则取消订单等等，这些都可以使用延时任务来实现。 jdk中DelayQueue可以实现上述需求，顾名思义DelayQueue就是延时队列。 DelayQueue提供了在指定时间才能获取队列元素的功能，队列头元素是最接近过期的元素。 没有过期元素的话，使用...
延时任务-基于redis zset的完整实现
m0_72134256的博客
08-23 325
所谓的延时任务给大家举个例子：你买了一张火车票，必须在30分钟之内付款，否则该订单被自动取消。这两种方法都有一个缺点：都是基于单体应用的内存的方式运行延时任务的，一旦出现单点故障，可能出现延时任务数据的丢失。所以此篇文章给大家介绍实现延时任务的第三种方式，结合redis zset实现延时任务，可以解决单点故障的问题。给出实现原理、完整实现代码，以及这种实现方式的优缺点。
实战：10 种实现延迟任务的方法，附代码！
uuqaz的博客
08-01 366
顾明思议，我们把需要延迟执行的任务叫做延迟任务。延迟任务的使用场景有以下这些红包24小时未被查收，需要延迟执退还业务；每个月账单日，需要给用户发送当月的对账单；订单下单之后30分钟后，用户如果没有付钱，系统需要自动取消订单。等事件都需要使用延迟任务。...
timeoutqueue:异步执行功能
05-06
timeoutqueue-异步执行功能 一个用于异步执行功能的简单库。 队列中的所有功能执行完毕后，将调用完成的回调。
日常设计-- 延迟队列
起风
11-23 964
最近项目需要用到延迟队列，本来考虑使用MQ实现，但由于目前使用RocketMq，不支持灵活的延迟时间配置，最终采用redis实现延迟功能。 一. Redis ZSET实现延迟队列 大体思路：使用ZSet结构，以messageId作为value，延迟时间delayTIme作为score。每次获取小于当前时间的数据。 推送消息 推送消息只是简单将数据以及延迟时间放入延迟队列中。 public void push(long messageId,long delayTime) { long s
DelayQueue延时任务队列总结和实践
hello world
05-30 3493
DelayQueue里面是一个无界的BlockingQueue，且有一个优先级队列 而且该优先级队列里面的实现是堆排序，这样每插入一个新的任务，都可以立即调整任务的顺序。 DelayQueue里面放的元素必须为实现了Delayed接口的任务。 里面有两个核心方法 getDelay 用于判断任务是否到期，如果是返回-1 表示任务已经到期 我这里用**（创建时间+延期时间-当前时间**）来做判断 c...
java 使用ScheduledExecutorService实现定时轮询，包含超时时间
weixin_42215988的博客
07-05 3957
  首先使用这个是为了MQTT发布的时候同步订阅响应的主题返回相应的信息，mqtt不能同步返回消息就是麻烦。方案就是：1. MQTT发布topic2. 每隔0.1秒进行轮询，查询redis缓存的数据3. MQTT订阅后把返回信息放在redis缓存4. 查询redis缓存有数据，退出轮询String devNum ="dev001"; ScheduledExecutorService servi...
验证阻塞队列超时机制
u011801264的专栏
08-29 1812
验证阻塞队列超时机制。
SpringTask实现定时任务
豪华的博客
05-19 596
本文主要讲解mall整合SpringTask的过程，以批量修改超时订单为例。
RabbitMQ中的死信队列和消息超时的简单使用
whiteBearClimb的博客
10-08 1774
概念： 消息超时 这个很简单，队列中的消息，不设置超时时间并且消费者宕机，就会越放越多，所以我们可以在创建queue的时候设置一个队列大小和队列超时时间。 死信交换机和死信队列： 专门收集一些拒绝接受的，超时未消费的，超出了队列大小的消息任务。 使用场景： （1）10件商品，100个用户进来购买，队列中大小设置为10，只允许10用户购买请求进来，其他的都reject，reject的这部分都会自动进行死信队列中，这也可以换成超出队列大小的情况。 （2）10件商品，100个用户进来购买，全部购买请求都放过期时
Java定时器任务3种实现方式(可用于解决过期、超时等需求)
Bummon的学习随笔
12-28 6544
定时任务在实际的开发中特别常见，比如电商平台 30 分钟后自动取消未支付的订单，以及凌晨的数据汇总和备份等，都需要借助定时任务来实现，那么我们本文就来看一下定时任务最简单的几种实现方式。 TOP 1：Timer Timer 是 JDK 自带的定时任务执行类，无论任何项目都可以直接使用 Timer 来实现定时任务，所以 Timer 的优点就是使用方便，它的实现代码如下： public class MyTimerTask { public static void main(String[] ar
Java阻塞队列深度解析：原理与应用
文章详细介绍了阻塞队列提供的四种处理方法，包括抛出异常、返回特殊值、一直阻塞和超时退出。同时，列举并解析了Java 7中的七大阻塞队列实现，如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue等...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值