Java分布式延时队列的实现实例：

1. 使用Netty实现延时队列

Netty是一个高性能的网络框架，它提供了HashedWheelTimer来实现定时任务，可以用于构建延时队列。

import io.netty.util.HashedWheelTimer;
import io.netty.util.Timeout;
import io.netty.util.TimerTask;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class TestNettyWheel {
    public static void main(String[] args) {
        HashedWheelTimer hashedWheelTimer = new HashedWheelTimer(Executors.defaultThreadFactory(), 1, TimeUnit.SECONDS, 12);
        System.out.println("任务开始执行时间：" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
        hashedWheelTimer.newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                System.out.println("13秒后输出：" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            }
        }, 13, TimeUnit.SECONDS);
        hashedWheelTimer.newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                System.out.println("29秒后输出：" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            }
        }, 29, TimeUnit.SECONDS);
        hashedWheelTimer.newTimeout(new TimerTask() {
            @Override
            public void run(Timeout timeout) throws Exception {
                System.out.println("14秒后输出：" + new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()));
            }
        }, 14, TimeUnit.SECONDS);
    }
}

2. 使用Redis实现延时队列

Redis可以通过sorted set和publish/subscribe机制实现延时队列。

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class RedisDelayedQueue {
    private JedisPool jedisPool;

    public RedisDelayedQueue(JedisPool jedisPool) {
        this.jedisPool = jedisPool;
    }

    public void offer(String key, String value, long delaySeconds) {
        try (Jedis jedis = jedisPool.getResource()) {
            jedis.zadd(key, System.currentTimeMillis() + delaySeconds * 1000, value);
        }
    }

    public String poll(String key) {
        try (Jedis jedis = jedisPool.getResource()) {
            long now = System.currentTimeMillis();
            Set<String> values = jedis.zrangeByScore(key, "-inf", now);
            if (!values.isEmpty()) {
                String value = values.iterator().next();
                jedis.zrem(key, value);
                return value;
            }
            return null;
        }
    }
}

3. 使用Redisson实现延时队列

Redisson提供了RDelayedQueue，这是一个基于Redis的分布式延时队列实现。

import org.redisson.Redisson;
import org.redisson.api.RDelayedQueue;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

public class RedissonDelayedQueueExample {
    public static void main(String[] args) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379");
        RedissonClient redisson = Redisson.create(config);

        RDelayedQueue<String> delayedQueue = redisson.getDelayedQueue(10, TimeUnit.SECONDS);
        delayedQueue.offer("message1");
        delayedQueue.offer("message2");

        String message = delayedQueue.poll();
        System.out.println("Taken message: " + message);
    }
}

这些实例展示了如何使用不同的技术栈实现分布式延时队列。您可以根据实际需求选择合适的实现方式。