使用延时队列DelayQueue实现订单超时自动关闭
DelayQueue 是一个线程安全的队列。可以实现异步操作
首先创建一个订单实体类
@Getter
@Setter
public class OrderInfo implements Serializable , Delayed
{
private static final long serialVersionUID = 1L;
private String orderNo;// 订单号
private Integer status;// 订单状态
private String expTime;// 订单过期时间
private String createTime;//订单创建时间
/**
* 用于延时队列内部比较排序:当前订单的过期时间 与 队列中对象的过期时间 比较
*/
@Override
public int compareTo(Delayed o) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long nowThreadtime = 0;
long queueThreadtime = 0;
try {
nowThreadtime = formatter.parse(this.expTime).getTime();
queueThreadtime = formatter.parse(((OrderInfo)o).expTime).getTime();
} catch (ParseException e) {
e.printStackTrace();
}
return Long.valueOf(nowThreadtime).compareTo(Long.valueOf(queueThreadtime));
}
/**
* 时间单位:秒
* 延迟关闭时间 = 过期时间 - 当前时间
*/
@Override
public long getDelay(TimeUnit unit) {
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
long time = 0;
try {
time = formatter.parse(this.expTime).getTime();
} catch (ParseException e) {
e.printStackTrace();
}
return time - System.currentTimeMillis();
}
}
下面实现队列移除超市订单
/**
* [使用延时队列DelayQueue实现订单超时关闭]
* [后台守护线程不断的执行检测工作]
* [双检查模式实现单例模式]
*/
@Component
public class OrderOverTimeClose
{
private volatile static OrderOverTimeClose oderOverTimeClose = null;
//我这里是一个商品订单实体类
private GoodsOrderRepository goodsOrderRepository;
private OrderOverTimeClose() {
this.goodsOrderRepository = ApplicationContextProvider.getBean(GoodsOrderRepository.class);
}
/**
* 单例模式,双检查锁模式,在并发环境下对象只被初始化一次
*/
public static OrderOverTimeClose getInstance(){
if(oderOverTimeClose == null ){
synchronized(OrderOverTimeClose.class){
oderOverTimeClose = new OrderOverTimeClose();
}
}
return oderOverTimeClose;
}
/**
* 守护线程
*/
private Thread mainThread;
/**
* 启动方法
*/
public void init(){
/**初始化时加载数据库中需处理超时的订单**/
//循环订单 获取状态 调用orderPutQueue();
// 创建初始订单
long createTime = System.currentTimeMillis();
String currentTime = OrderPay.getTime(createTime);
String overTime = OrderPay.getTime(createTime + 1800000);// 三十分钟后超时 10000毫秒=10秒
//启动的时候找到需要的订单信息
List<GoodsOrder> goodsOrders = goodsOrderRepository.findBy("status","1");
//循环订单信息 把需要的信息 放进队列的实体类
goodsOrders.forEach((info)->{
OrderInfo orderInfo = new OrderInfo();
orderInfo.setOrderNo(info.getOrderNum());
orderInfo.setStatus(info.getStatus());
orderInfo.setCreateTime(currentTime);
orderInfo.setExpTime(overTime);
orderPutQueue(orderInfo,currentTime,overTime);
});
mainThread = new Thread(() -> execute());
mainThread.setDaemon(true);
mainThread.setName("守护线程-->");
mainThread.start();
}
/**
* 创建空延时队列
*/
private DelayQueue<OrderInfo> queue = new DelayQueue<OrderInfo>();
/**
* 读取延时队列,关闭超时订单
*/
private void execute() {
while (true) {
try {
if(queue.size() > 0){
//从队列里获取超时的订单
OrderInfo orderInfo = queue.take();
// 检查订单状态,是否已经成功,成功则将订单从队列中删除。
if (orderInfo.getStatus()>1) {
System.out.println("线程:"+Thread.currentThread().getName()+",订单号:"
+ orderInfo.getOrderNo() + ",订单状态:"
+ orderInfo.getStatus() + ",订单创建时间:"
+ orderInfo.getCreateTime()
+ ",订单超时时间:" + orderInfo.getExpTime()+",当前时间:"+OrderPay.getTime(System.currentTimeMillis()));
orderRemoveQueue(orderInfo);
System.out.println("订单已成功 移除掉"+orderInfo.getOrderNo());
Thread.sleep(2000);
} else {
//这里是超时的订单 把超时的订单状态改为取消
GoodsOrderRepository goodsOrderRepository = ApplicationContextProvider.getBean(GoodsOrderRepository.class);
GoodsOrder goodsOrder = goodsOrderRepository.findOneBy("orderNum",orderInfo.getOrderNo());
if( goodsOrder!=null && goodsOrder.getStatus()<=1 )
{
goodsOrder.setStatus(GoodsOrder.orderType.cancelOrder);//取消订单
goodsOrder.setCancelTime(new Date());
goodsOrderRepository.saveOrUpdate(goodsOrder);
}else
{
orderRemoveQueue(orderInfo);
System.out.println("订单已成功 移除掉"+orderInfo.getOrderNo());
}
System.out.println("线程:"+Thread.currentThread().getName()+",订单号:"
+ orderInfo.getOrderNo() + ",变更订单状态为:超时关闭"
+ ",订单创建时间:"
+ orderInfo.getCreateTime()
+ ",订单超时时间:" + orderInfo.getExpTime()+",当前时间:"+OrderPay.getTime(System.currentTimeMillis()));
Thread.sleep(2000);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
/**
* 插入订单到超时队列中
*/
public void orderPutQueue(OrderInfo orderInfo, String createTime,
String overTime) {
System.out.println("订单号:" + orderInfo.getOrderNo() + ",订单创建时间:"
+ createTime + ",订单过期时间:" + overTime);
queue.add(orderInfo);
}
/**
* 从延迟队列中移除
*/
public void orderRemoveQueue(OrderInfo orderInfo){
if(null == orderInfo){
return;
}
for (Iterator<OrderInfo> iterator = queue.iterator(); iterator.hasNext();) {
OrderInfo info = (OrderInfo) iterator.next();
if(orderInfo.getOrderNo().equals(info.getOrderNo())){
queue.remove(info);
}
}
}
}
创建一个测试类
/**
* 模拟订单支付,创建订单
*/
public class OrderPay
{
static Integer[] str = new Integer[]{1,2,3};
public static String getTime(long time){
SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date(time);
String currentTime = formatter.format(date);
return currentTime;
}
public static void main(String[] args) throws InterruptedException {
OrderOverTimeClose.getInstance().init();
ExecutorService service = Executors.newFixedThreadPool(10);
for (int i = 0; i < 2; i++) {
Runnable run = new Runnable() {
@Override
public void run() {
// 创建初始订单
long createTime = System.currentTimeMillis();
String currentTime = getTime(createTime);
String overTime = getTime(createTime + 10000);// 十秒后超时
String orderNo = String.valueOf(new Random().nextLong());
OrderInfo order = new OrderInfo();
order.setOrderNo(orderNo);
order.setExpTime(overTime);
int random_index = (int) (Math.random()*str.length);
order.setStatus(str[random_index]);// 随机分配
order.setCreateTime(currentTime);
OrderOverTimeClose.getInstance().orderPutQueue(order, currentTime, overTime);
}
};
service.execute(run);
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
好了 去试试吧 如果那里错了 或者不懂得 请指出来 Vx 号 AiMyHear