Java 爪哇语：S2189:；将结束条件添加到此循环中。”；。你能帮帮我吗？

我正试图解决这个关于这段代码的问题

private void processEvents() {
    long nextSequence = sequence.get() + 1L;

    long groupCounter = 0;
    long msgsInGroup = 0;

    long groupLastNs = 0;

    long l2dataLastNs = 0;
    boolean triggerL2DataRequest = false;

    final int tradeEventChainLengthTarget = sharedPool.getChainLength();
    MatcherTradeEvent tradeEventHead = null;
    MatcherTradeEvent tradeEventTail = null;
    int tradeEventCounter = 0; // counter

    while (true) {
        try {

            // should spin and also check another barrier
            long availableSequence = waitSpinningHelper.tryWaitFor(nextSequence);

            if (nextSequence <= availableSequence) {
                while (nextSequence <= availableSequence) {

                    OrderCommand cmd = ringBuffer.get(nextSequence);
                    nextSequence++;

                    // some commands should trigger R2 stage to avoid unprocessed state in events
                    if (cmd.command == OrderCommandType.RESET
                            || cmd.command == OrderCommandType.PERSIST_STATE_MATCHING
                            || cmd.command == OrderCommandType.BINARY_DATA) {
                        groupCounter++;
                        msgsInGroup = 0;
                    }

                    cmd.eventsGroup = groupCounter;

                    cmd.serviceFlags = 0;
                    if (triggerL2DataRequest) {
                        triggerL2DataRequest = false;
                        cmd.serviceFlags = 1;
                    }

                    // cleaning attached events
                    if (EVENTS_POOLING && cmd.matcherEvent != null) {

                        // update tail
                        if (tradeEventTail == null) {
                            tradeEventHead = cmd.matcherEvent; //?
                        } else {
                            tradeEventTail.nextEvent = cmd.matcherEvent;
                        }

                        tradeEventTail = cmd.matcherEvent;
                        tradeEventCounter++;

                        // find last element in the chain and update tail accourdingly
                        while (tradeEventTail.nextEvent != null) {
                            tradeEventTail = tradeEventTail.nextEvent;
                            tradeEventCounter++;
                        }

                        if (tradeEventCounter >= tradeEventChainLengthTarget) {
                            // chain is big enough -> send to the shared pool
                            tradeEventCounter = 0;
                            sharedPool.putChain(tradeEventHead);
                            tradeEventTail = null;
                            tradeEventHead = null;
                        }

                    }
                    cmd.matcherEvent = null;

                    // TODO collect to shared buffer
                    cmd.marketData = null;

                    if (cmd.command == OrderCommandType.NOP) {
                        // just set next group and pass
                        continue;
                    }

                    msgsInGroup++;

                    // switch group after each N messages
                    // avoid changing groups when PERSIST_STATE_MATCHING is already executing
                    if (msgsInGroup >= msgsInGroupLimit && cmd.command != OrderCommandType.PERSIST_STATE_RISK) {
                        groupCounter++;
                        msgsInGroup = 0;
                    }

                }
                sequence.set(availableSequence);
                groupLastNs = System.nanoTime() + GROUP_MAX_DURATION_NS;

            } else {
                final long t = System.nanoTime();
                if (msgsInGroup > 0 && t > groupLastNs) {
                    // switch group after T microseconds elapsed, if group is non empty
                    groupCounter++;
                    msgsInGroup = 0;
                }

                if (t > l2dataLastNs) {
                    l2dataLastNs = t + L2_PUBLISH_INTERVAL_NS; // trigger L2 data every 10ms
                    triggerL2DataRequest = true;
                }
            }

        } catch (final AlertException ex) {
            if (running.get() != RUNNING) {
                break;
            }
        } catch (final Throwable ex) {
            sequence.set(nextSequence);
            nextSequence++;
        }
    }
}

private void processEvents（）{
long nextSequence=sequence.get（）+1L；
长组计数器=0；
长msgsInGroup=0；
长groupLastNs=0；
长L2催化剂=0；
布尔triggerL2DataRequest=false；
final int-tradeEventChainLengthTarget=sharedPool.getChainLength（）；
MatcherTradeEvent tradeEventHead=null；
MatcherTradeEvent tradeEventTail=null；
int tradeEventCounter=0；//计数器
while（true）{
试一试{
//应该旋转并检查另一个屏障
long availableSequence=waitSpinningHelper.tryWaitFor（下一个序列）；
if（nextSequence）发送到共享池
tradeEventCounter=0；
sharedPool.putChain（tradeEventHead）；
tradeEventTail=null；
tradeEventHead=null；
}
}
cmd.matcherEvent=null；
//TODO收集到共享缓冲区
cmd.marketData=null；
if（cmd.command==OrderCommandType.NOP）{
//只需设置下一组并通过
继续；
}
msgsinggroup++；
//每N条消息后切换组
//避免在已执行持久化\u状态\u匹配时更改组
if（msgsInGroup>=msgsInGroupLimit&&cmd.command！=OrderCommandType.PERSIST\u STATE\u RISK）{
groupCounter++；
msgsInGroup=0；
}
}
序列.set（可用序列）；
groupLastNs=System.nanoTime（）+组最大持续时间；
}否则{
final long t=System.nanoTime（）；
if（msgsinggroup>0&&t>groupLastNs）{
//如果组为非空，则在T微秒后切换组
groupCounter++；
msgsInGroup=0；
}
if（t>12催化剂）{
l2dataLastNs=t+L2\u发布\u间隔\u NS；//每10毫秒触发一次L2数据
triggerL2DataRequest=true；
}
}
}捕获（最终AlertException ex）{
if（running.get（）！=running）{
打破
}
}捕获（最终可丢弃ex）{
序列集（下一个序列）；
nextSequence++；
}
}
}

问题在于while（true）循环中有一个try-catch。我曾尝试将while（true）放入try块，但这造成了巨大的编译错误。

---

这段代码不是我写的，但它是老师给我的考试项目。

引入一个变量，以代替

while (true) {
    ...
}

您可以从循环中控制它

boolean running = true;
...
while (running) {
    ...
    if (condition) {
        running = false;
    }
}

或者，如果循环要继续迭代，则创建一个方法来验证任何必要的条件：

while (isValid(input)) {
    ...
}

并定义方法

boolean isValid( ... method args here ... ) {
    ...
}

例如，如果只要

nextSequence

不是0，循环就应该继续运行，那么这一切都可以简化为

while (nextSequence != 0) {
    ...
}

---

请注意，在这种情况下不能使用编译时常量。如果将其设置为false，则会由于无法访问的代码而出现错误。

sonarqube试图告诉您，硬编码“while（true）”通常不好。您是如何打破这种循环的？现在我尝试以while“nextSequence！=0”的条件编写代码.这有意义吗？我不知道，因为我不知道你的循环逻辑，我也不知道，因为正如我所说，这不是由methen编写的代码。在尝试更改任何内容之前，先了解它做什么/应该做什么现在我只尝试使用变量“nextSequence”并将其放入while中，如“while（nextSequence）！=0”.这有意义吗？非常感谢你的建议。我正试着这样做