Java：当一个事件实际上丢失时，如何对收集事件消息的 class 设置时间限制

Question

I want to find a way to prevent a 'collector' class from waiting forever, because its contents are incomplete, and it has no way to know that the missing event msg(s) don't exist to be passed to it.

I have an class named EventSet that has related event msgs (from monitoring) passed to it from a JMS onMessage listener. Each related event has a seq no and the last event is called 'TxnEnd' - this has the highest seq-no. When the total of event msgs is equal the seq-no of TxnEnd, I know all events are present and my code instructs the callback class to process the set of events.

When there is a missing event, that instance of EventSet sits there patiently waiting for ever.

My idea to solve this is to somehow set a limit on the wait time, at the point when the Class is created. When that is exceeded, my code should instruct the callback to handle the incomplete set of events.

I have spent mich time on two previous occasions, over the pst 2/3 months, trying this and that, based on suggestions and ideas - without success. Until now, it's been possible to park this as it almost never happens. Now, I do need to solve it.

In essence, it seems like a reasonably common situation which should have a straight forward solution. I have failed to find one.

I will be gratreful for any suggestions or solutions.

Answer 1

I dont' know if your libraries support this approach, but a plain Java attempt would look something like this:

public class MessageProcessor extends Thread {
  private static final long PROCESSOR_TIMEOUT   = 3600 * 1000 /* 1 hour? */;
  private static final long ONE_MESSAGE_TIMEOUT = 1000 /* 1 sec? */;
  private long              m_startTime         = 0;

  public void startProcessing() {
    m_startTime = System.currentTimeMillis();
    start();
  }

  @Override
  public void run() {
    while(true) {
      // ---------------------------------
      // check abort condition
      // ---------------------------------
      if(System.currentTimeMillis() - m_startTime > PROCESSOR_TIMEOUT) {
        break;
      }

      // ---------------------------------
      // handle 1 message (with timeout)
      // ---------------------------------
      try {
        // pseudo code
        collectOneMessage(ONE_MESSAGE_TIMEOUT);
      }
      catch(InterruptedException e) {
        // ignoring timeout exception
      }
    }

    // ---------------------------------
    // finish up
    // ---------------------------------
    // ...
  }
}

Answer 2

The solution was to use a Timer and a TimerTask (as an inner class). The constructor creates the Timer and schedules the TimerTask for the required number of seconds, If all related events are received, the callback is invoked and the timer is cancelled. In the rare cases where an event is missing, the TimerTask kicks in and sends an incomplete set of events to the callback and logs an error.

FYI.

public class EventSet {

private MonitorEventsConsumer eventsConsumer;

// For timeout handling
private Timer timer;
private int waitTime; // seconds to wait 

protected boolean isComplete;

private String localTxnId;
String eventSourceAddress;
private boolean txnEndReceived;
private int maxCounter = 0;
private List<String> monEvents = new ArrayList<>();


public EventSet(String localTxnId) {
    this(localTxnId, 20); // Default the waiting time for all events to be received to 20 secs
}
public EventSet(String localTxnId, int waitTime) {
    this.localTxnId = localTxnId;
    timer = new Timer();
    this.waitTime = waitTime;
    timer.schedule(new TimeoutTask(), waitTime*1000);
}

public boolean isNew() {
    return monEvents.isEmpty();
}

public void addEvent(String eventAsXML) {

    monEvents.add(eventAsXML);
    String counter = StringUtils.substringBetween(eventAsXML, "wmb:counter=\"", "\"/>");
    eventSourceAddress = StringUtils.substringBetween(eventAsXML, " wmb:eventSourceAddress=\"", "\">");
    if (eventSourceAddress.endsWith("transaction.End")) {
        txnEndReceived = true;
    }
    
    int iCounter = Integer.parseInt(counter);
    if (iCounter > maxCounter) {
        maxCounter = iCounter;
    }

    if (txnEndReceived && maxCounter == monEvents.size()) {
        // all events should have been received unless maxCounter = 1
        // Call back to the onMessageHandler to process this event set.
        eventsConsumer.sendEventsToNjams(localTxnId, this);
        isComplete = true;
        timer.cancel();
    }
}

public List<String> getMonEvents() {
    return monEvents;
}

public void clear() {
    monEvents.clear();
    localTxnId = null;
    isComplete = false;
    maxCounter = 0;
}

public void registerHandler(final MonitorEventsConsumer eventsConsumer) {
    if (this.eventsConsumer == null) {
        this.eventsConsumer = eventsConsumer;
    }
}

class TimeoutTask extends TimerTask {
    public void run() {            
        eventsConsumer.sendEventsToNjams(localTxnId, EventSet.this);
        isComplete = true;
        System.err.println(String.format("Message events for local txn id '%s' were incomplete after waiting for %d seconds. they were sent to nJAMS in this state", localTxnId, waitTime));
        timer.cancel(); //Terminate the timer thread
    }
}

}