使用DelayQueue模拟订单超时自动取消

1.创建能在DelayQueue中存放的Order对象

package com.example.javastudy.delay_queue;

import java.time.Duration;
import java.util.concurrent.Delayed;
import java.util.concurrent.TimeUnit;

public class Order implements  Delayed {

    private Long createTime;
    private String number;
    private Duration duration;

    public Order(Long createTime, String number, Duration duration) {
        this.createTime = createTime;
        this.number = number;
        this.duration = duration;
    }

	//take()方法判断是否可以出队
    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(( createTime + duration.toMillis() - System.currentTimeMillis()),TimeUnit.MILLISECONDS);
    }

    @Override
    public int compareTo(Delayed o) {
        if(this == o){
            return 0;
        }
        if(o instanceof Order){
            Order target = (Order) o;
            return createTime.compareTo(target.createTime);
        }else {
          long gap = getDelay(TimeUnit.NANOSECONDS) - o.getDelay(TimeUnit.NANOSECONDS);
          return gap == 0 ? 0 : (gap < 0 ? -1:1);
        }

    }

    public Long getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Long createTime) {
        this.createTime = createTime;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public Duration getDuration() {
        return duration;
    }

    public void setDuration(Duration duration) {
        this.duration = duration;
    }
}

2.订单业务

public class OrderService {
    public final BlockingQueue<Order> queue = new DelayQueue<>();
    private final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
            1,2,0, TimeUnit.MILLISECONDS,new LinkedBlockingDeque<>()
            );
    public void cancelDelayOrder(){
            threadPool.execute(() ->{
               for (;;){
                    try {
                        Order order = queue.take();
                        String number = order.getNumber();
                        System.out.println("=============>订单："+number+"已取消"+"当前系统时间："+new Date());
                        for (Order next : queue) {
                            System.out.println("=============>订单编号：" + next.getNumber());
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    }
}

3.测试类

public class OrderTest {
    static OrderService orderService = new OrderService();
    //订单初始化
    static void initial(){
        Random random = new Random();
        for (int i = 0; i < 4; i++) {
            Order order = new Order(System.currentTimeMillis(),"订单"+(i+1), Duration.ofSeconds(20));
            orderService.queue.add(order);
            int randomSleep = random.nextInt(5);
            System.out.println("=============>订单"+(i+1)+"创建成功,当前时间："+new Date());
            try {
                TimeUnit.SECONDS.sleep(randomSleep);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        System.out.println("=================系统初始化成功");

        StringBuilder number = new StringBuilder();
        for (Order order : orderService.queue) {
            number.append(order.getNumber()).append("|");
        }
        System.out.println("=================系统当前订单有："+number);
    }

    public static void main(String[] args) {
        initial();
        orderService.cancelDelayOrder();
    }
}

测试结果可以看出，当订单到达过期时间后订单就被取消了