延迟队列andRedis：未支付订单的却分钟自动关闭

定时任务：10秒执行

import com.basetnt.sun.valley.service.DelayService;
import com.basetnt.sun.valley.service.RoomOrderService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.text.ParseException;
@Component
public class OrderTask {

    @Autowired
    private DelayService delayService;


    private final static Logger log = LoggerFactory.getLogger(com.basetnt.sun.valley.task.ScheduleTask.class);

    @Scheduled(cron = "0/10 * *  * * ? ")
    public void run() throws ParseException {
        delayService.payPoll();
    }
}

继承队列：放入队列的实体类

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

public class OrderExt implements Delayed {

    private String orderId;
    private long startTime;

    /**
     * orderId:订单id
     * timeout：自动取消订单的超时时间，秒
     */
    public OrderExt(String orderId, int timeout) {
        this.orderId = orderId;
        this.startTime = System.currentTimeMillis() + timeout * 1000L;
    }

    @Override
    public int compareTo(Delayed other) {
        if (other == this) {
            return 0;
        }
        if (other instanceof OrderExt) {
            OrderExt otherRequest = (OrderExt) other;
            long otherStartTime = otherRequest.getStartTime();
            return (int) (this.startTime - otherStartTime);
        }
        return 0;
    }

    @Override
    public long getDelay(TimeUnit unit) {
        return unit.convert(startTime - System.currentTimeMillis(), TimeUnit.MILLISECONDS);
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public long getStartTime() {
        return startTime;
    }

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

}

队列的相关操作

import com.basetnt.sun.valley.entityExt.OrderExt;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class DelayService {

    @Autowired
    private RoomOrderService roomOrderService;


    private boolean start;
    private OnDelayedListener listener;
    private DelayQueue<OrderExt> delayQueue = new DelayQueue<OrderExt>();


    public static interface OnDelayedListener {
        public void onDelayedArrived(OrderExt order);
    }


    public void start(OnDelayedListener listener) {
        if (start) {
            return;
        }
        log.error("DelayService 启动");
        start = true;
        this.listener = listener;
        new Thread(new Runnable() {
            public void run() {
                try {
                    while (true) {
                        OrderExt order = delayQueue.take();
                        if (DelayService.this.listener != null) {
                            DelayService.this.listener.onDelayedArrived(order);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    /**
     * 添加
     *
     * @param order
     */
    public void add(OrderExt order) {
        delayQueue.put(order);
    }


    /**
     * 删除
     *
     * @param orderId
     */
    public void remove(String orderId) {
        OrderExt[] array = delayQueue.toArray(new OrderExt[]{});
        if (array == null || array.length <= 0) {
            return;
        }
        OrderExt target = null;
        for (OrderExt order : array) {
            if (order.getOrderId() == orderId) {
                target = order;
                break;
            }
        }
        if (target != null) {
            delayQueue.remove(target);
        }
    }


    /**
     * 轮询队列
     */
    public void payPoll() throws ParseException {
        //循环延时队列，判断是否有元素，有则表示有过时未支付订单，(在队列中的数据“过期”之后才能返回数据，不然只能获取到null。)
        //获取到订单的id，得到订单信息，删除redis中的key，删除队列中的该订单
        //将订单状态改为已取消。。。
        if (delayQueue != null && delayQueue.size() > 0) {
            for (OrderExt orderExt : delayQueue) {
                String orderId = orderExt.getOrderId();
                if (orderExt.getDelay(TimeUnit.MILLISECONDS) <= 0) {
                    //执行的操作
                }
            }
        }
    }
}