在java中阅读10分钟前的消息

我正试图实现一个生产者和消费者。 生产者将继续将消息推送到队列中。 但是，消费者只有在到达队列30分钟后才能阅读这些消息

假设

m1 reaches at 10am 
m2 reaches at 10.10am
m3 reaches at 10.20am

消费者必须在指定地点挑选

m1 at 10.30am
m2 at 10.40am
m3 at 10.50am 

在java中有什么方法可以做吗

我尝试了BlockingQueue，但我不认为我们可以使用BlockingQueue将其存档。 在BlockingQueue中，当消息在队列中可用时，消费者将立即读取

任何帮助都将不胜感激。

DelayQueue

Java内置了和的一个实现，它只在元素指定的延迟期到期后才提供元素

提供给队列的对象必须有一定的等待时间，这是通过实现接口定义的。此接口需要一个方法：。该接口还有一个要求：

此接口的实现必须定义一个方法，该方法提供与其

getDelay

方法一致的顺序

定义消息类以满足这两个要求

public class DelayedMessage implements Delayed , Comparable {…}

定义队列以承载该类型的对象

BlockingQueue< DelayedMessage > queue = new DelayQueue<>() ;

接下来我们使用

消息

类。我们将

Message

对象存储在

DelayQueue

中。我们转储该队列以查看和验证其内容

然后我们创建一个后台线程，每秒检查一次队列。如果我们从队列中得到

null

，我们将忽略它。如果我们从队列中获得一个

消息

对象，我们将以UTC为单位写入当前时刻，然后写入该消息对象的

toString

输出。我们将这项工作安排在一个时间表上（见）

运行此应用程序时请等待一分钟。一分钟后，executor服务将关闭，并向控制台写入带有当前时刻的通知，让您知道应用程序已成功结束运行

package work.basil.example;

import java.time.Duration;
import java.time.Instant;
import java.util.Objects;
import java.util.Queue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class DemoDelayQueue
{
    public static void main ( String[] args )
    {
        DemoDelayQueue app = new DemoDelayQueue();
        app.demo();
    }

    private void demo ( )
    {
        System.out.println( "App beginning now: " + Instant.now() );

        BlockingQueue < Message > queue = new DelayQueue <>();
        queue.add( new Message( "Message delayed 5 seconds." , Duration.ofSeconds( 5 ) ) );
        queue.add( new Message( "Message delayed 47 seconds." , Duration.ofSeconds( 47 ) ) );
        queue.add( new Message( "Message delayed 3 seconds." , Duration.ofSeconds( 3 ) ) );
        queue.add( new Message( "Message delayed 12 seconds." , Duration.ofSeconds( 12 ) ) );
        System.out.println( "queue = " + queue );

        ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor();
        ses.scheduleAtFixedRate(
                ( ) -> {
                    Message m = queue.poll();
                    if ( Objects.nonNull( m ) )
                    {
                        System.out.println( "--------" );
                        System.out.println( "Retrieved `Message` object from queue at: " + Instant.now() );
                        System.out.println( m.toString() );
                    } 
                    else // Else `m` is null. 
                    {
                        // System.out.println( "No message available. Null returned by queue." ) ;
                    }
                }
                ,
                0 ,
                1 ,
                TimeUnit.SECONDS
        );

        try
        {
            Thread.sleep( TimeUnit.MINUTES.toMillis( 1 ) );
        }
        catch ( InterruptedException e )
        {
            e.printStackTrace();
        }
        finally
        {
            ses.shutdown();
            System.out.println( "App ending now: " + Instant.now() );
        }
    }
}

package work.basil.example;

import java.time.Duration;
import java.time.Instant;
import java.util.Objects;
import java.util.Queue;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class DemoDelayQueue
{
    public static void main ( String[] args )
    {
        DemoDelayQueue app = new DemoDelayQueue();
        app.demo();
    }

    private void demo ( )
    {
        System.out.println( "App beginning now: " + Instant.now() );

        BlockingQueue < Message > queue = new DelayQueue <>();
        queue.add( new Message( "Message delayed 5 seconds." , Duration.ofSeconds( 5 ) ) );
        queue.add( new Message( "Message delayed 47 seconds." , Duration.ofSeconds( 47 ) ) );
        queue.add( new Message( "Message delayed 3 seconds." , Duration.ofSeconds( 3 ) ) );
        queue.add( new Message( "Message delayed 12 seconds." , Duration.ofSeconds( 12 ) ) );
        System.out.println( "queue = " + queue );

        ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor();
        ses.scheduleAtFixedRate(
                ( ) -> {
                    Message m = queue.poll();
                    if ( Objects.nonNull( m ) )
                    {
                        System.out.println( "--------" );
                        System.out.println( "Retrieved `Message` object from queue at: " + Instant.now() );
                        System.out.println( m.toString() );
                    } 
                    else // Else `m` is null. 
                    {
                        // System.out.println( "No message available. Null returned by queue." ) ;
                    }
                }
                ,
                0 ,
                1 ,
                TimeUnit.SECONDS
        );

        try
        {
            Thread.sleep( TimeUnit.MINUTES.toMillis( 1 ) );
        }
        catch ( InterruptedException e )
        {
            e.printStackTrace();
        }
        finally
        {
            ses.shutdown();
            System.out.println( "App ending now: " + Instant.now() );
        }
    }
}