一口气说出Java 6种延时队列的实现方法(面试官也得服)

public class Order implements Delayed {
  /**
   * 延迟时间
   */
  @JsonFormat(locale = "zh", timezone = "GMT+8", pattern = "yyyy-MM-dd HH:mm:ss")
  private long time;
  String name;
  
  public Order(String name, long time, TimeUnit unit) {
    this.name = name;
    this.time = System.currentTimeMillis() + (time > 0 ? unit.toMillis(time) : 0);
  }
  
  @Override
  public long getDelay(TimeUnit unit) {
    return time - System.currentTimeMillis();
  }
  @Override
  public int compareTo(Delayed o) {
    Order Order = (Order) o;
    long diff = this.time - Order.time;
    if (diff <= 0) {
      return -1;
    } else {
      return 1;
    }
  }
}

public class DelayQueueDemo {

  public static void main(String[] args) throws InterruptedException {
    Order Order1 = new Order("Order1", 5, TimeUnit.SECONDS);
    Order Order2 = new Order("Order2", 10, TimeUnit.SECONDS);
    Order Order3 = new Order("Order3", 15, TimeUnit.SECONDS);
    DelayQueue<Order> delayQueue = new DelayQueue<>();
    delayQueue.put(Order1);
    delayQueue.put(Order2);
    delayQueue.put(Order3);

    System.out.println("订单延迟队列开始时间:" + LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
    while (delayQueue.size() != 0) {
      /**
       * 取队列头部元素是否过期
       */
      Order task = delayQueue.poll();
      if (task != null) {
        System.out.format("订单:{%s}被取消, 取消时间:{%s}\n", task.name, LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
      }
      Thread.sleep(1000);
    }
  }
}

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

@EnableScheduling
@SpringBootApplication
public class DelayqueueApplication {
	public static void main(String[] args) {
		SpringApplication.run(DelayqueueApplication.class, args);
	}
}

@Component
public class QuartzDemo {

  //每隔五秒
  @Scheduled(cron = "0/5 * * * * ? ")
  public void process(){
    System.out.println("我是定时任务！");
  }
}

zadd delayqueue 3 order3

 /**
   * 消费消息
   */
  public void pollOrderQueue() {

    while (true) {
      Set<Tuple> set = jedis.zrangeWithScores(DELAY_QUEUE, 0, 0);

      String value = ((Tuple) set.toArray()[0]).getElement();
      int score = (int) ((Tuple) set.toArray()[0]).getScore();
      
      Calendar cal = Calendar.getInstance();
      int nowSecond = (int) (cal.getTimeInMillis() / 1000);
      if (nowSecond >= score) {
        jedis.zrem(DELAY_QUEUE, value);
        System.out.println(sdf.format(new Date()) + " removed key:" + value);
      }

      if (jedis.zcard(DELAY_QUEUE) <= 0) {
        System.out.println(sdf.format(new Date()) + " zset empty ");
        return;
      }
      Thread.sleep(1000);
    }
  }

notify-keyspace-events Ex

@Configuration
public class RedisListenerConfig {
  @Bean
  RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory) {

    RedisMessageListenerContainer container = new RedisMessageListenerContainer();
    container.setConnectionFactory(connectionFactory);
    return container;
  }
}

@Component
public class RedisKeyExpirationListener extends KeyExpirationEventMessageListener {
 
  public RedisKeyExpirationListener(RedisMessageListenerContainer listenerContainer) {
    super(listenerContainer);
  }
  @Override
  public void onMessage(Message message, byte[] pattern) {
    String expiredKey = message.toString();
    System.out.println("监听到key：" + expiredKey + "已过期");
  }
}

set xiaofu 123 ex 3

public void send(String delayTimes) {
    amqpTemplate.convertAndSend("order.pay.exchange", "order.pay.queue","大家好我是延迟数据", message -> {
      // 设置延迟毫秒值
      message.getMessageProperties().setExpiration(String.valueOf(delayTimes));
      return message;
    });
  }
}

/**
   * 延时队列
   */
  @Bean(name = "order.delay.queue")
  public Queue getMessageQueue() {
    return QueueBuilder
        .durable(RabbitConstant.DEAD_LETTER_QUEUE)
        // 配置到期后转发的交换
        .withArgument("x-dead-letter-exchange", "order.close.exchange")
        // 配置到期后转发的路由键
        .withArgument("x-dead-letter-routing-key", "order.close.queue")
        .build();
  }

public HashedWheelTimer(ThreadFactory threadFactory, long tickDuration, TimeUnit unit, int ticksPerWheel) {
    this(threadFactory, tickDuration, unit, ticksPerWheel, true);
  }

public class NettyDelayQueue {

  public static void main(String[] args) {

    final Timer timer = new HashedWheelTimer(Executors.defaultThreadFactory(), 5, TimeUnit.SECONDS, 2);

    //定时任务
    TimerTask task1 = new TimerTask() {
      public void run(Timeout timeout) throws Exception {
        System.out.println("order1 5s 后执行 ");
        timer.newTimeout(this, 5, TimeUnit.SECONDS);//结束时候再次注册
      }
    };
    timer.newTimeout(task1, 5, TimeUnit.SECONDS);
    TimerTask task2 = new TimerTask() {
      public void run(Timeout timeout) throws Exception {
        System.out.println("order2 10s 后执行");
        timer.newTimeout(this, 10, TimeUnit.SECONDS);//结束时候再注册
      }
    };

    timer.newTimeout(task2, 10, TimeUnit.SECONDS);

    //延迟任务
    timer.newTimeout(new TimerTask() {
      public void run(Timeout timeout) throws Exception {
        System.out.println("order3 15s 后执行一次");
      }
    }, 15, TimeUnit.SECONDS);

  }
}