Question

我已经实现了一个简单的Spring Boot应用程序，它接收网络消息，使用appender.writeText（str）将其排入SingleChronicleQueue，另一个线程使用tailer.readText（）轮询消息。经过一些处理后，处理过的消息将被放置在另一个SingleChronicleQueue中以便发送出去。我在应用程序中有三个队列。

应用程序每晚都会旋转文件，第一个奇怪的事情是文件大小（每个Q）都相同（每个Q都不同）。最大的cq4文件大约每天220MB。

我面临的问题是，从开始到现在的三天内，内存从480MB增长到1.6GB，这是不合理的。

我有一个概念，即我在配置中遗漏了一些东西，或者我的一个天真/糟糕的实现。（我不会在每次使用后关闭appender和tailer，如果我）。

这是一个精简的例子，也许有人可以解决一些问题。

@Service
public class QueuesService {
    private static Logger LOG = LoggerFactory.getLogger(QueuesService.class);

    @Autowired
    AppConfiguration conf;

    private SingleChronicleQueue Q = null;
    private ExcerptAppender QAppender = null;
    private ExcerptTailer QTailer = null;

    public QueuesService() {
    }

    @PostConstruct
    private void init() {

        Q = SingleChronicleQueueBuilder.binary(conf.getQueuePath()).indexSpacing(1).build();
        QAppender = Q.acquireAppender();
        QTailer = Q.createTailer();
    }

    public ExcerptAppender getQAppender() {
        return QAppender;
    }

    public ExcerptTailer getQTailer() {
        return QTailer;
    }
}


@Service
public class ProcessingService {
    private static Logger LOG = LoggerFactory.getLogger(ProcessingService.class);

    @Autowired
    AppConfiguration conf;

    @Autowired
    private TaskExecutor taskExecutor;

    @Autowired
    private QueuesService queueService;

    private QueueProcessor processor = null;

    public ProcessingService() {
    }

    @PostConstruct
    private void init() {
        processor = new QueueProcessor();
        processor.start();
    }

    @Override
    public Message processMessage(Message msg, Map<String, Object> metadata) throws SomeException {

        String strMsg = msg.getMessage().toString();

        if (LOG.isInfoEnabled()) {
            LOG.info("\n" + strMsg);
        }

        try {
            queueService.getQAppender().writeText(strMsg);

            if (LOG.isInfoEnabled()) {
                LOG.info("Added new message to queue. index: " + queueService.getQAppender().lastIndexAppended());
            }
        }
        catch(Exception e) {
            LOG.error("Unkbown error. reason: " + e.getMessage(), e);
        }
    }

    class QueueProcessor extends Thread {

        public void run() {
            while (!interrupted()) {
                try {
                    String msg = queueService.getEpicQTailer().readText();

                    if (msg != null) {
                        long index = queueService.getEpicQTailer().index();
                        // process
                    }
                    else {
                        Thread.sleep(10);
                    }
                }
                catch (InterruptedException e) {
                    LOG.warn(e);
                    this.interrupt();
                    break;
                }
            }

            ThreadPoolTaskExecutor tp = (ThreadPoolTaskExecutor) taskExecutor;
            tp.shutdown();
        }
    }
}

Answer 1

Chronicle Queue旨在使用虚拟内存，它可以比主内存（或堆）大得多，而不会对系统造成重大影响。这使您可以快速随机访问数据。

以下是在3小时内编写1 TB的过程示例。

https://vanilla-java.github.io/2017/01/27/Chronicle-Queue-storing-1-TB-in-virtual-memory-on-a-128-GB-machine.html

这显示了队列增长的速度慢了多少

即使在128 GB的机器上它的大小为1 TB，它也会在2秒内写入1 GB。

虽然这不会引起技术问题，但我们知道这确实关注那些也发现这种情况的人，并且我们计划采用一种减少虚拟内存使用的模式（即使某些用例稍慢一点）

使用Chronicle-Queue内存的应用程序不断增长

1 个答案: