更新存储在阻塞优先级队列中的自定义对象

发布于 2024-10-28 02:27:16 字数 659 浏览 2 评论 0原文

我有一个阻塞优先级队列,它存储消息类型的对象,消息有 String[] data = new String[10]。现在我必须迭代整个阻塞队列,检查其对象消息的第二个元素是否等于传入消息的第六个元素。

Messages 的比较器不是基于需要更新的第 6 个元素。问题是,如果我取出一个对象,那么如何将它放在相同的位置,如果我使用下面的代码来更新它,那么每当运行 iter.next() 时,它可能会开始指向下一个对象。

这就是我正在尝试的。

public synchronized void updateAck(Message ackMessage)
    {
        Iterator iter  = localQ.iterator(); // localQ is the blocking priority queue here
        while(iter.hasNext())
        {
            if(((Message)iter.next()).data[2].equalsIgnoreCase(ackMessage.data[6]))
            {
                (Integer.parseInt((Message)iter.next()).data[6])+1);

            }
        }
    }

I have a blocking priority queue which stores Objects of type Message, message has String[] data = new String[10]. Now I have to iterate over whole blocking Queue, check if its Object message's 2nd element is equal to 6th element of an incoming message.

The comparator of Messages is not based on 6th element which needs to be updated. Problem is that if I take out an object then how to put it at same position and if I use the code below to update it then anytime iter.next() is run it may start pointing to next Object.

Here is what I am trying.

public synchronized void updateAck(Message ackMessage)
    {
        Iterator iter  = localQ.iterator(); // localQ is the blocking priority queue here
        while(iter.hasNext())
        {
            if(((Message)iter.next()).data[2].equalsIgnoreCase(ackMessage.data[6]))
            {
                (Integer.parseInt((Message)iter.next()).data[6])+1);

            }
        }
    }

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(2

久隐师 2024-11-04 02:27:16

不要在 if 条件中直接使用 (Message)iter.next(),而是尝试这样做。

Message queMessage = (Message)iter.next();

完整代码

 while(iter.hasNext())
{

    Message queMessage = (Message)iter.next(); //you will be invoking .next() only once

     if(queMessage.data[2].equalsIgnoreCase(ackMessage.data[6]))
     {
          (Integer.parseInt(queMessage.data[6])+1);

     }
}

Instead of directly using (Message)iter.next() in your if conditions, try this.

Message queMessage = (Message)iter.next();

Full code

 while(iter.hasNext())
{

    Message queMessage = (Message)iter.next(); //you will be invoking .next() only once

     if(queMessage.data[2].equalsIgnoreCase(ackMessage.data[6]))
     {
          (Integer.parseInt(queMessage.data[6])+1);

     }
}

似乎在实时队列上执行此操作有些危险,具体取决于下游消费者的期望。

怎么样:

  • 当一个 ack 进来时,初始化一个新的 BlockingQueue
  • 在新的空队列中原子交换旧的完整队列
  • 将旧队列中的元素排入新队列,进行任何比较/需要逐个元素进行更改

如果这种情况经常发生,也许您需要一对队列;一个是活的;另一个是影子。

It seems like doing this operation on a live queue is somewhat dangerous, depending on what the downstream consumer is expecting.

How about this:

  • When an ack comes in, initialize a new BlockingQueue
  • Atomic swap in the new, empty queue for the old full one
  • Drain the elements from the old queue into the new one, making whatever comparisons/changes need to be made element by element

If this happens a lot, maybe you need a pair of queues; one is the live one; the other is the shadow.

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文